diff --git a/.gitattributes b/.gitattributes
index a6344aac8c09253b3b630fb776ae94478aa0275b..039aa9b54d45d7562993a5a7f535e96c9b52ab25 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/fig2.png filter=lfs diff=lfs merge=lfs -text
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..896be7e1bc28dfad7eab19cb6320fb3e3a025a35
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,28 @@
+# syntax=docker/dockerfile:1.7
+# Linux/amd64 descriptor resolved from the official Python registry on 2026-07-28.
+ARG BASE_IMAGE=python:3.12-slim@sha256:cab2dbf575e971934a81e4622f5aba17aa7929719bd7e31033a3a83b97fd0464
+FROM ${BASE_IMAGE}
+
+ARG SCIENCE_SPEC_SHA256=c0ded12138cb7c15a15966294ed9bdb87d3a66d2373a7d90050578dbb973c6fd
+LABEL org.opencontainers.image.title="neutral-sheaf-admm-reproduction"
+LABEL org.opencontainers.image.licenses="Apache-2.0"
+LABEL org.opencontainers.image.revision="1e2b5d648361802234348b0b1a7fb3a222128e7d"
+LABEL reproduction.science-spec-sha256="${SCIENCE_SPEC_SHA256}"
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    JAX_DEFAULT_MATMUL_PRECISION=highest \
+    TRACE_MODE=none \
+    TRACKIO_LOGBOOK_AUTONOTE=0
+
+WORKDIR /repro
+COPY pyproject.toml uv.lock LICENSE SCIENCE-SPEC.yaml ./
+RUN test "$(sha256sum SCIENCE-SPEC.yaml | cut -d' ' -f1)" = "${SCIENCE_SPEC_SHA256}" \
+    && python -m pip install --no-cache-dir uv==0.11.9 \
+    && uv sync --frozen --no-dev
+COPY configs ./configs
+COPY src ./src
+COPY scripts ./scripts
+ENV PATH="/repro/.venv/bin:${PATH}" PYTHONPATH="/repro/src"
+EXPOSE 7860
+CMD ["python", "-m", "http.server", "7860"]
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..74b79ffe5039e7a486b70b468c24a66df94478d0
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,161 @@
+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.
+
+"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 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
diff --git a/README.md b/README.md
index 3345b1f8427300f8a77ce62118d290bd04a815aa..6e25e6c4eba58ec99e466390f9c64a7705bcde50 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,115 @@
 ---
-title: Sheaf Admm Icml2026 Executor
-emoji: 🌖
+title: Sheaf-ADMM ICML 2026 Reproduction Executor
+emoji: 🧩
 colorFrom: indigo
 colorTo: blue
 sdk: docker
+app_port: 7860
 pinned: false
+license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Sheaf-ADMM
+
+![Sheaf-ADMM overview](assets/fig2.png)
+
+Official JAX/Flax implementation of **Learning Multi-Agent Coordination via
+Sheaf-ADMM** (ICML 2026).
+
+[![arXiv](https://img.shields.io/badge/arXiv-2605.31005-b31b1b?style=flat-square)](https://arxiv.org/abs/2605.31005)
+[![Blog](https://img.shields.io/badge/Blog-Sakana%20AI-1f6feb?style=flat-square)](https://pub.sakana.ai/sheaf-admm/)
+
+Sheaf-ADMM decomposes an input into overlapping local views, each processed by an
+agent that solves a small convex subproblem parameterized by a neural encoder.
+Agents coordinate through the Alternating Direction Method of Multipliers (ADMM),
+with the inter-agent constraints specified by a *cellular sheaf* — which aspects
+of neighboring solutions must agree. The optimization is unrolled for a fixed
+number of iterations, so the whole pipeline is differentiable and every component
+is trained end-to-end.
+
+## Installation
+
+This repository is intended to be run from a source checkout. Install
+[uv](https://docs.astral.sh/uv/getting-started/installation/), then run:
+
+```bash
+uv sync
+```
+
+For CUDA experiments, install a JAX build matching your driver:
+
+```bash
+uv pip install -U "jax[cuda12]"
+```
+
+## Data
+
+```bash
+uv run python -m sheaf_admm.data.build_maze \
+  --height 19 \
+  --width 19 \
+  --train-size 10000 \
+  --test-size 1000 \
+  --min-path-length 18 \
+  --ood-sizes \
+  --output-dir datasets/maze_std3_19px_10k
+
+uv run python -m sheaf_admm.data.build_mnist \
+  --output-dir datasets/mnist
+
+uv run python -m sheaf_admm.data.build_sudoku \
+  --output-dir datasets/sudoku_easy
+```
+
+The MNIST and Sudoku builders download their source datasets on first run.
+
+## Training
+
+Each task has a Sheaf-ADMM model and a recurrent-MPNN baseline:
+
+```bash
+# Maze
+uv run python scripts/train.py +experiment=maze_sheaf
+uv run python scripts/train.py +experiment=maze_mpnn
+
+# MNIST
+uv run python scripts/train.py +experiment=mnist_sheaf
+uv run python scripts/train.py +experiment=mnist_mpnn
+
+# Sudoku
+uv run python scripts/train.py +experiment=sudoku_sheaf
+uv run python scripts/train.py +experiment=sudoku_sheaf_lora
+uv run python scripts/train.py +experiment=sudoku_mpnn
+```
+
+Set `training.seed=42`, `123`, or `456` for the paper seeds. Set
+`wandb.mode=online` to enable Weights & Biases logging. Checkpoints and
+`history.json` are written to Hydra's run directory under `outputs/`.
+
+## Visualization
+
+The visualization script expects a Sheaf-ADMM checkpoint:
+
+```bash
+uv run python -m scripts.visualize \
+  --checkpoint outputs/<date>/<time>/checkpoint.pkl \
+  --out-dir /tmp/sheaf_admm_viz
+```
+
+## Checks
+
+```bash
+uv run python -m ruff check .
+uv run python -m pytest -q
+```
+
+## Citation
+
+```bibtex
+@inproceedings{sheafadmm2026,
+  title     = {Learning Multi-Agent Coordination via Sheaf-ADMM},
+  author    = {Seely, Jeffrey and Cupia{\l}, Bart{\l}omiej and Jones, Llion},
+  booktitle = {International Conference on Machine Learning (ICML)},
+  year      = {2026},
+}
+```
diff --git a/SCIENCE-SPEC.yaml b/SCIENCE-SPEC.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d780f96af9ae39930c1c8f4558f95df1ce38f8d9
--- /dev/null
+++ b/SCIENCE-SPEC.yaml
@@ -0,0 +1,1653 @@
+{
+  "authorities": {
+    "approved_protocol_sha256": "f4904e05e8abd051281926abec6774c6fe39b84160367f0bfde806b0669e0c2b",
+    "base_image": "python:3.12-slim@sha256:cab2dbf575e971934a81e4622f5aba17aa7929719bd7e31033a3a83b97fd0464",
+    "canonical_claims_sha256": "26ca2fa3697061cb71a91a0f687ab5ce99e908b7b50c009ee2efcc645695d489",
+    "challenge_dataset_revision": "81166abbeb76e5f79ff87e51061b5a0306507203",
+    "challenge_space_revision": "5bbcad2e9a7e8a7479f3563ac1fc6c768d4bb050",
+    "deadline_utc": "2026-08-03T11:59:00Z",
+    "dependency_lock_sha256": "e9dd209b20905a9a553c30ab1bab0259d2c665ee7805942744d9c5f198610bd7",
+    "execution_bucket": "Mindcraft/sheaf-admm-icml2026-runs",
+    "execution_image_space": "Mindcraft/sheaf-admm-icml2026-executor",
+    "input_bucket": "Mindcraft/sheaf-admm-icml2026-inputs",
+    "paper_sha256": "95d6de2011cdeaf4eeba6c7cc320146a530183da7f045457227cab3165b83a70",
+    "poster_commit": "e503c399b5427ca6cb712ccb080a758e9c19cf23",
+    "space_id": "Mindcraft/repro-learning-multi-agent-coordination-via-sheaf-admm",
+    "sudoku_dataset_revision": "4d5aa527a9fb9aacca0b0d5b8b77d569fa9afcaa",
+    "trace_mode": "none",
+    "trackio_logbook_autonote": 0,
+    "trackio_version": "0.33.0",
+    "trackio_wheel_sha256": "277340507ac46c02c06900c1d680129bdb528223c8110b0b6bc9326bb9f0891d",
+    "upstream_commit": "1e2b5d648361802234348b0b1a7fb3a222128e7d"
+  },
+  "budget_limits": {
+    "billing_quantum": "ceil(rate*1e6*ceil(seconds/60)/60)",
+    "gpu_retry_reserve_micro_usd": 10000000,
+    "minimum_unspent_balance_micro_usd": 10000000,
+    "normal_cap_micro_usd": 75000000
+  },
+  "data_rules": {
+    "c5": {
+      "K": 100,
+      "exact_figure6_protocol": "unreleased",
+      "examples_per_size": 1000,
+      "generator_seed_formula": "21005000+n",
+      "min_path_length_formula": "3*(n-1)/2",
+      "n19_replacements": true,
+      "overlap_rejection": "canonical wall/start/goal/path against training",
+      "realized_minimum": [
+        27,
+        33,
+        39,
+        45,
+        51,
+        57
+      ],
+      "sizes": [
+        19,
+        23,
+        27,
+        31,
+        35,
+        39
+      ],
+      "test_augmentation": false
+    },
+    "maze": {
+      "builder": "released_deterministic_DFS",
+      "height": 19,
+      "min_path_length": 18,
+      "ood_sizes": true,
+      "test_size": 1000,
+      "train_size": 10000,
+      "width": 19
+    },
+    "mnist": {
+      "agent_count": 81,
+      "clean": true,
+      "drop_agents": 24,
+      "drop_effect": [
+        "zero_3x3_pixels",
+        "remove_incident_sheaf_edges",
+        "exclude_removed_agents_from_vote"
+      ],
+      "drop_fraction_label": "30%",
+      "mask_derivation": [
+        "dataset_revision",
+        "example_id",
+        "condition",
+        "master_seed"
+      ],
+      "master_seed": 21005300,
+      "padding_pixels": 16,
+      "tier": "B_target_informed_nonconfirmatory"
+    },
+    "sudoku": {
+      "revision": "4d5aa527a9fb9aacca0b0d5b8b77d569fa9afcaa",
+      "source": "Ritvik19/Sudoku-Dataset",
+      "test_rows": [
+        50000,
+        52000
+      ],
+      "test_split": "test_hard",
+      "train_augmentation": "eight_way",
+      "train_rows": [
+        0,
+        50000
+      ]
+    }
+  },
+  "evaluators": {
+    "C5-EVAL-2X-GENERALIZATION-A": {
+      "physical_jobs": 1,
+      "shard": "deterministic_lpt_A"
+    },
+    "C5-EVAL-2X-GENERALIZATION-B": {
+      "physical_jobs": 1,
+      "shard": "deterministic_lpt_B"
+    },
+    "MAZE-EVAL-C2-C4B": {
+      "physical_jobs": 1,
+      "units": [
+        "imported_default_3",
+        "mpnn84_3",
+        "quadratic_3"
+      ]
+    },
+    "MNIST-EVAL-C3": {
+      "conditions": [
+        "clean",
+        "pad16",
+        "drop30"
+      ],
+      "physical_jobs": 1,
+      "units": [
+        "imported_sheaf_3",
+        "cnn_3"
+      ]
+    },
+    "SUD-EVAL-C1-C4A": {
+      "physical_jobs": 1,
+      "units": [
+        "imported_sheaf_3",
+        "mpnn225_3",
+        "identity_3"
+      ]
+    }
+  },
+  "failure_classes": [
+    "INVALID_INPUT",
+    "INCOMPLETE_OUTPUT",
+    "HASH_MISMATCH",
+    "CONFIG_MISMATCH",
+    "CAPABILITY_VIOLATION",
+    "READINESS_TIMEOUT",
+    "HEARTBEAT_TIMEOUT",
+    "INFRASTRUCTURE",
+    "CODE_PARITY",
+    "DATA_ASSERTION",
+    "BUDGET_GATE",
+    "DEADLINE_GATE",
+    "PRIVACY_FINDING",
+    "AMBIGUOUS_SUBMISSION"
+  ],
+  "fixture_rules": {
+    "disjoint_from_final_generators": true,
+    "id_prefix": "smoke-",
+    "maze_seed_formula": "91005200+n",
+    "mnist_seed": 91005301,
+    "purpose": [
+      "compile",
+      "memory",
+      "timing",
+      "serialization",
+      "one_step_gradient"
+    ],
+    "sudoku_seed": 91005101,
+    "verdict_metrics_forbidden": true
+  },
+  "format": 1,
+  "hardware_routes": {
+    "maze_c5": {
+      "fallback": {
+        "flavor": "l40sx1",
+        "usd_per_hour": "1.80"
+      },
+      "primary": {
+        "flavor": "l4x1",
+        "usd_per_hour": "0.80"
+      }
+    },
+    "mnist": {
+      "fallback": {
+        "flavor": "l40sx1",
+        "usd_per_hour": "1.80"
+      },
+      "primary": {
+        "flavor": "l4x1",
+        "usd_per_hour": "0.80"
+      }
+    },
+    "sudoku": {
+      "fallback": {
+        "flavor": "h200",
+        "usd_per_hour": "5.00"
+      },
+      "primary": {
+        "flavor": "a100-large",
+        "usd_per_hour": "2.50"
+      }
+    }
+  },
+  "imports": [
+    {
+      "checkpoint_sha256": "4444ca900b84911f778ade7fb4c682853308fac6008748ff644f5193122951b8",
+      "config_sha256": "831675683b8ca586616be95d7377a2ed1da776a04cc9457b5b4f855c5598e74a",
+      "ema_decay": 0.999,
+      "final_epoch": 19,
+      "neutral_alias": "mnist-sheaf-seed-42",
+      "seed": 42,
+      "task": "mnist"
+    },
+    {
+      "checkpoint_sha256": "34b693aac81e1ab880324726eb6db80e35e0683f3c997a2d082acd5c9393a5f6",
+      "config_sha256": "c1f902d7509c5a2dbd0130757b55607b51016e2a9039392da4b09b79c694c978",
+      "ema_decay": 0.999,
+      "final_epoch": 19,
+      "neutral_alias": "mnist-sheaf-seed-123",
+      "seed": 123,
+      "task": "mnist"
+    },
+    {
+      "checkpoint_sha256": "f35206c24e79df75878e330ff01ff489ec29f82ae11eb3de04f401e2e4d2a3e5",
+      "config_sha256": "3a3c11e55551b9b820696abb7cf28ea94d4295e022c5da9525adfb802ee77d17",
+      "ema_decay": 0.999,
+      "final_epoch": 19,
+      "neutral_alias": "mnist-sheaf-seed-456",
+      "seed": 456,
+      "task": "mnist"
+    },
+    {
+      "checkpoint_sha256": "7a8295f5af4f52c2ec5963fa35e7e3906ebce5ea433551bfc9017e4a9825de9c",
+      "config_sha256": "6e93a94469a1cec98dd2dc3ff9df91ce613ad99d18a5cae0388b8a42a610595a",
+      "ema_decay": 0.999,
+      "final_epoch": 49,
+      "neutral_alias": "maze-sheaf-seed-42",
+      "seed": 42,
+      "task": "maze"
+    },
+    {
+      "checkpoint_sha256": "bd1369916039e3984911951217c7ae083efe6696f06f6cec9f2f5c009187a6f5",
+      "config_sha256": "8621e9687a39a5f28e5178561c4a6da9dbff09595dbc1340e1e97710c8af82d5",
+      "ema_decay": 0.999,
+      "final_epoch": 49,
+      "neutral_alias": "maze-sheaf-seed-123",
+      "seed": 123,
+      "task": "maze"
+    },
+    {
+      "checkpoint_sha256": "a61191e0a3ec14aa245acc4b566dc7dd6caafba69365f9aa347dc2f906e95f38",
+      "config_sha256": "0566b34b360220bcc8e32cea6236884a9b7a693c68ca1cdc56861ab95ec7da13",
+      "ema_decay": 0.999,
+      "final_epoch": 49,
+      "neutral_alias": "maze-sheaf-seed-456",
+      "seed": 456,
+      "task": "maze"
+    },
+    {
+      "checkpoint_sha256": "53fb0f4c287bb419247956a3ab4492acb42cde6a3c3335ed1c18694c705d163e",
+      "config_sha256": "66ac9154bb1a15483211e0e8458cea4250181fdabc864c1748f89561535621fb",
+      "ema_decay": 0.999,
+      "final_epoch": 9,
+      "neutral_alias": "sudoku-sheaf-seed-42",
+      "seed": 42,
+      "task": "sudoku"
+    },
+    {
+      "checkpoint_sha256": "a16e792b46aeca8ca6dc9d9323217328ecf43e0ce32022870c5626186997511f",
+      "config_sha256": "f080a4055a676a5094204fc78de5e2f57c07dd2f67af8c55cf7615dcb818d47d",
+      "ema_decay": 0.999,
+      "final_epoch": 9,
+      "neutral_alias": "sudoku-sheaf-seed-123",
+      "seed": 123,
+      "task": "sudoku"
+    },
+    {
+      "checkpoint_sha256": "7a6937eedf75f553965c21b5dda5c4da8164489125159f6fc8465e9159b2b3af",
+      "config_sha256": "1649e4d4e047bcceefb9b13ebee6fa830eeac668445714457a2ed258563a9625",
+      "ema_decay": 0.999,
+      "final_epoch": 9,
+      "neutral_alias": "sudoku-sheaf-seed-456",
+      "seed": 456,
+      "task": "sudoku"
+    }
+  ],
+  "lifecycle": {
+    "CPU_CANARY": {
+      "science_freeze_sha256": "NOT_APPLICABLE",
+      "science_spec_sha256": "NOT_APPLICABLE"
+    },
+    "CPU_IMPORT": {
+      "science_freeze_sha256": "NOT_APPLICABLE",
+      "science_spec_sha256": "EXACT"
+    },
+    "GPU_SMOKE": {
+      "science_freeze_sha256": "NOT_APPLICABLE",
+      "science_spec_sha256": "EXACT"
+    },
+    "SCIENTIFIC_EVAL": {
+      "control_mount": "/repro-control read-only",
+      "science_freeze_sha256": "EXACT",
+      "science_spec_sha256": "EXACT"
+    },
+    "SCIENTIFIC_TRAIN": {
+      "control_mount": "/repro-control read-only",
+      "science_freeze_sha256": "EXACT",
+      "science_spec_sha256": "EXACT"
+    }
+  },
+  "metrics": {
+    "c1": "Sudoku exact puzzle accuracy and parameter count",
+    "c2": "Maze exact puzzle accuracy and per-vertex latent dimension ratio",
+    "c3": "MNIST classification accuracy by condition",
+    "c4": "Sudoku exact puzzle accuracy and Maze exact puzzle accuracy",
+    "c5": "Maze exact puzzle accuracy by size",
+    "replication_unit": "training_seed",
+    "report": [
+      "every_seed",
+      "mean",
+      "sample_standard_deviation",
+      "student_t_interval",
+      "paper_value",
+      "unrounded_delta"
+    ],
+    "same_seed_comparisons": "paired",
+    "t_critical": {
+      "90_df2": 2.919985580355516,
+      "95_df2": 4.302652729911275
+    }
+  },
+  "outcomes": {},
+  "protocol_status": "frozen_pre_mutation",
+  "reducers": {
+    "c1": {
+      "negative": "Sheaf_mean<85 or MPNN_mean>20 or U95(paired_gap)<=60",
+      "parameter_match": "relative_count_mismatch<=0.05",
+      "support": "Sheaf_mean>=85 and MPNN_mean<=20 and L95(paired_gap)>60"
+    },
+    "c2": {
+      "negative": "either mean<90 or interval wholly beyond equivalence bounds",
+      "ratio": "84/10=8.4x per-vertex latent dimension",
+      "support": "both means>=95 and paired_90_interval within [-2,2]"
+    },
+    "c3": {
+      "adequacy": "each mean>=98.5 and each seed>=98.0",
+      "negative": "either upper interval<=threshold",
+      "required_suffix": "DROPOUT_SEMANTICS_TARGET_SELECTED",
+      "support": "L95(pad_gap)>20 and L95(drop_gap)>10"
+    },
+    "c4_maze": {
+      "falsifies_collapse": "default_mean>=90 and quadratic_mean>=90 and U95(default-quadratic)<20",
+      "required_suffix": "PROMPT_MISSTATES_PAPER_TABLE",
+      "supports_direction": "default_mean>=90 and quadratic_mean<=60 and L95(default-quadratic)>20"
+    },
+    "c4_sudoku": {
+      "negative": "learned_mean<85 or identity_mean>15 or U95(gap)<=60",
+      "support": "learned_mean>=85 and identity_mean<=15 and L95(gap)>60"
+    },
+    "c5": {
+      "negative": "any mean<95",
+      "required_suffix": "INCONCLUSIVE_EXACT_DENSE_FIGURE6_CONFIG_UNRELEASED",
+      "support": "all six three-seed means>=95"
+    },
+    "precedence": [
+      "invalid_or_incomplete",
+      "supported_or_negative",
+      "ambiguous_or_inconclusive"
+    ]
+  },
+  "registered_configs": {
+    "C1-SUD-MPNN225-123": {
+      "canonical_sha256": "703fe3f833c3b2910a92783710faee4893ddb333d008b4784288171e78fa56f5",
+      "config": {
+        "data": {
+          "dir": "/data/train/sudoku_easy",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "comm_norm_type": "layernorm",
+          "d_e": 32,
+          "d_v": 225,
+          "dec_hidden_dims": [
+            256
+          ],
+          "decoder_arch": "sudoku",
+          "enc_d_model": 128,
+          "enc_num_blocks": 2,
+          "encoder_arch": "sudoku",
+          "mpnn_aggregation": "max",
+          "mpnn_edge_type_mode": "slot",
+          "mpnn_graph_readout": "per_node",
+          "mpnn_message_dim": 32,
+          "num_classes": 10,
+          "num_directions": 9
+        },
+        "model_type": "mpnn",
+        "task": "sudoku",
+        "task_cfg": {},
+        "training": {
+          "K_eval": 100,
+          "K_train": 40,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 10,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 4,
+          "lr": 0.0017,
+          "mpnn_eval_rounds": 50,
+          "mpnn_train_rounds": 20,
+          "seed": 123,
+          "train_iters_dist": "fixed",
+          "train_iters_min": 15,
+          "val_interval": 1,
+          "warmup_steps": 200,
+          "weight_decay": 1e-07
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C1-SUD-MPNN225-123.json"
+    },
+    "C1-SUD-MPNN225-42": {
+      "canonical_sha256": "a0a0fad0c015647c5b03f31542c7f01fd2648ad04c19360b82d6dc3e060e3af2",
+      "config": {
+        "data": {
+          "dir": "/data/train/sudoku_easy",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "comm_norm_type": "layernorm",
+          "d_e": 32,
+          "d_v": 225,
+          "dec_hidden_dims": [
+            256
+          ],
+          "decoder_arch": "sudoku",
+          "enc_d_model": 128,
+          "enc_num_blocks": 2,
+          "encoder_arch": "sudoku",
+          "mpnn_aggregation": "max",
+          "mpnn_edge_type_mode": "slot",
+          "mpnn_graph_readout": "per_node",
+          "mpnn_message_dim": 32,
+          "num_classes": 10,
+          "num_directions": 9
+        },
+        "model_type": "mpnn",
+        "task": "sudoku",
+        "task_cfg": {},
+        "training": {
+          "K_eval": 100,
+          "K_train": 40,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 10,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 4,
+          "lr": 0.0017,
+          "mpnn_eval_rounds": 50,
+          "mpnn_train_rounds": 20,
+          "seed": 42,
+          "train_iters_dist": "fixed",
+          "train_iters_min": 15,
+          "val_interval": 1,
+          "warmup_steps": 200,
+          "weight_decay": 1e-07
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C1-SUD-MPNN225-42.json"
+    },
+    "C1-SUD-MPNN225-456": {
+      "canonical_sha256": "b1e99a06aafa6fa0255a8c4c4141b5e7da37a72f21e0388fe10ab45528454a44",
+      "config": {
+        "data": {
+          "dir": "/data/train/sudoku_easy",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "comm_norm_type": "layernorm",
+          "d_e": 32,
+          "d_v": 225,
+          "dec_hidden_dims": [
+            256
+          ],
+          "decoder_arch": "sudoku",
+          "enc_d_model": 128,
+          "enc_num_blocks": 2,
+          "encoder_arch": "sudoku",
+          "mpnn_aggregation": "max",
+          "mpnn_edge_type_mode": "slot",
+          "mpnn_graph_readout": "per_node",
+          "mpnn_message_dim": 32,
+          "num_classes": 10,
+          "num_directions": 9
+        },
+        "model_type": "mpnn",
+        "task": "sudoku",
+        "task_cfg": {},
+        "training": {
+          "K_eval": 100,
+          "K_train": 40,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 10,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 4,
+          "lr": 0.0017,
+          "mpnn_eval_rounds": 50,
+          "mpnn_train_rounds": 20,
+          "seed": 456,
+          "train_iters_dist": "fixed",
+          "train_iters_min": 15,
+          "val_interval": 1,
+          "warmup_steps": 200,
+          "weight_decay": 1e-07
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C1-SUD-MPNN225-456.json"
+    },
+    "C2-MAZE-MPNN84-123": {
+      "canonical_sha256": "545effae66a4ab9a6c802d32eaa28b06bf664a3618cac556aadd42a39285b40b",
+      "config": {
+        "data": {
+          "dir": "/data/train/maze_std3_19px_10k",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "comm_norm_type": "layernorm",
+          "d_e": 42,
+          "d_v": 84,
+          "dec_hidden_dim": 256,
+          "decoder_arch": "mlp_concat_v2",
+          "enc_hidden_dim": 256,
+          "encoder_arch": "mlp_v2",
+          "mpnn_aggregation": "max",
+          "mpnn_edge_type_mode": "spatial",
+          "mpnn_graph_readout": "per_node",
+          "mpnn_message_dim": 42,
+          "num_classes": 6,
+          "num_directions": 8
+        },
+        "model_type": "mpnn",
+        "task": "maze",
+        "task_cfg": {
+          "connectivity": 8,
+          "num_classes": 6,
+          "patch_size": 3,
+          "stride": 2
+        },
+        "training": {
+          "K_eval": 100,
+          "K_train": 40,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 50,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 4,
+          "lr": 0.0003,
+          "mpnn_eval_rounds": 100,
+          "mpnn_train_rounds": 40,
+          "seed": 123,
+          "train_iters_dist": "fixed",
+          "train_iters_min": 15,
+          "val_interval": 5,
+          "warmup_steps": 200,
+          "weight_decay": 1e-06
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C2-MAZE-MPNN84-123.json"
+    },
+    "C2-MAZE-MPNN84-42": {
+      "canonical_sha256": "f826d5b2c392645ceabd97ed219310e4c8dd8278dce3c935b893ef6ec67c598d",
+      "config": {
+        "data": {
+          "dir": "/data/train/maze_std3_19px_10k",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "comm_norm_type": "layernorm",
+          "d_e": 42,
+          "d_v": 84,
+          "dec_hidden_dim": 256,
+          "decoder_arch": "mlp_concat_v2",
+          "enc_hidden_dim": 256,
+          "encoder_arch": "mlp_v2",
+          "mpnn_aggregation": "max",
+          "mpnn_edge_type_mode": "spatial",
+          "mpnn_graph_readout": "per_node",
+          "mpnn_message_dim": 42,
+          "num_classes": 6,
+          "num_directions": 8
+        },
+        "model_type": "mpnn",
+        "task": "maze",
+        "task_cfg": {
+          "connectivity": 8,
+          "num_classes": 6,
+          "patch_size": 3,
+          "stride": 2
+        },
+        "training": {
+          "K_eval": 100,
+          "K_train": 40,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 50,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 4,
+          "lr": 0.0003,
+          "mpnn_eval_rounds": 100,
+          "mpnn_train_rounds": 40,
+          "seed": 42,
+          "train_iters_dist": "fixed",
+          "train_iters_min": 15,
+          "val_interval": 5,
+          "warmup_steps": 200,
+          "weight_decay": 1e-06
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C2-MAZE-MPNN84-42.json"
+    },
+    "C2-MAZE-MPNN84-456": {
+      "canonical_sha256": "2fb6db8a94a03033c21b698aeb700ebf2013abf803e4d34e23a778e3a5ab8d09",
+      "config": {
+        "data": {
+          "dir": "/data/train/maze_std3_19px_10k",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "comm_norm_type": "layernorm",
+          "d_e": 42,
+          "d_v": 84,
+          "dec_hidden_dim": 256,
+          "decoder_arch": "mlp_concat_v2",
+          "enc_hidden_dim": 256,
+          "encoder_arch": "mlp_v2",
+          "mpnn_aggregation": "max",
+          "mpnn_edge_type_mode": "spatial",
+          "mpnn_graph_readout": "per_node",
+          "mpnn_message_dim": 42,
+          "num_classes": 6,
+          "num_directions": 8
+        },
+        "model_type": "mpnn",
+        "task": "maze",
+        "task_cfg": {
+          "connectivity": 8,
+          "num_classes": 6,
+          "patch_size": 3,
+          "stride": 2
+        },
+        "training": {
+          "K_eval": 100,
+          "K_train": 40,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 50,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 4,
+          "lr": 0.0003,
+          "mpnn_eval_rounds": 100,
+          "mpnn_train_rounds": 40,
+          "seed": 456,
+          "train_iters_dist": "fixed",
+          "train_iters_min": 15,
+          "val_interval": 5,
+          "warmup_steps": 200,
+          "weight_decay": 1e-06
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C2-MAZE-MPNN84-456.json"
+    },
+    "C3-MNIST-CNN-123": {
+      "canonical_sha256": "528044762e54a8f02036c84c34836a857518c98b5aef2fec60d5352b04d89ef8",
+      "config": {
+        "data": {
+          "augmentation": false,
+          "dir": "/data/train/mnist",
+          "examples": 60000,
+          "input_range": [
+            0,
+            1
+          ],
+          "loader": "image",
+          "normalization": false,
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "layout": "NHWC/HWIO/NHWC",
+          "parameter_count": 65642,
+          "post_pool_sizes": [
+            14,
+            30
+          ],
+          "pre_pool_sizes": [
+            28,
+            60
+          ]
+        },
+        "model_type": "mnist_cnn_repro",
+        "task": "mnist",
+        "task_cfg": {},
+        "training": {
+          "batch_size": 128,
+          "betas": [
+            0.9,
+            0.999
+          ],
+          "ema_decay": 0.999,
+          "epoch_permutation": "fold_in(PRNGKey(seed),epoch)",
+          "epochs": 20,
+          "epsilon": 1e-08,
+          "final_batch": "pad_to_128_mask_normalize",
+          "grad_clip": 1.0,
+          "lr": 0.001,
+          "schedule": "linear_to_task_lr_then_constant",
+          "seed": 123,
+          "selection": "fixed_final_epoch",
+          "warmup_steps": 200,
+          "weight_decay": 1e-07
+        },
+        "wandb": {
+          "mode": "disabled"
+        }
+      },
+      "file": "control/registered-configs/C3-MNIST-CNN-123.json"
+    },
+    "C3-MNIST-CNN-42": {
+      "canonical_sha256": "442cbeddd56b3eba9dc239e84403285d135bca4868d58a315fe67fcd97b1f4f6",
+      "config": {
+        "data": {
+          "augmentation": false,
+          "dir": "/data/train/mnist",
+          "examples": 60000,
+          "input_range": [
+            0,
+            1
+          ],
+          "loader": "image",
+          "normalization": false,
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "layout": "NHWC/HWIO/NHWC",
+          "parameter_count": 65642,
+          "post_pool_sizes": [
+            14,
+            30
+          ],
+          "pre_pool_sizes": [
+            28,
+            60
+          ]
+        },
+        "model_type": "mnist_cnn_repro",
+        "task": "mnist",
+        "task_cfg": {},
+        "training": {
+          "batch_size": 128,
+          "betas": [
+            0.9,
+            0.999
+          ],
+          "ema_decay": 0.999,
+          "epoch_permutation": "fold_in(PRNGKey(seed),epoch)",
+          "epochs": 20,
+          "epsilon": 1e-08,
+          "final_batch": "pad_to_128_mask_normalize",
+          "grad_clip": 1.0,
+          "lr": 0.001,
+          "schedule": "linear_to_task_lr_then_constant",
+          "seed": 42,
+          "selection": "fixed_final_epoch",
+          "warmup_steps": 200,
+          "weight_decay": 1e-07
+        },
+        "wandb": {
+          "mode": "disabled"
+        }
+      },
+      "file": "control/registered-configs/C3-MNIST-CNN-42.json"
+    },
+    "C3-MNIST-CNN-456": {
+      "canonical_sha256": "2ba04eca4a4bec45d8cadb2c2363efe34b0ab731698ac12948f82c5ef288a099",
+      "config": {
+        "data": {
+          "augmentation": false,
+          "dir": "/data/train/mnist",
+          "examples": 60000,
+          "input_range": [
+            0,
+            1
+          ],
+          "loader": "image",
+          "normalization": false,
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "layout": "NHWC/HWIO/NHWC",
+          "parameter_count": 65642,
+          "post_pool_sizes": [
+            14,
+            30
+          ],
+          "pre_pool_sizes": [
+            28,
+            60
+          ]
+        },
+        "model_type": "mnist_cnn_repro",
+        "task": "mnist",
+        "task_cfg": {},
+        "training": {
+          "batch_size": 128,
+          "betas": [
+            0.9,
+            0.999
+          ],
+          "ema_decay": 0.999,
+          "epoch_permutation": "fold_in(PRNGKey(seed),epoch)",
+          "epochs": 20,
+          "epsilon": 1e-08,
+          "final_batch": "pad_to_128_mask_normalize",
+          "grad_clip": 1.0,
+          "lr": 0.001,
+          "schedule": "linear_to_task_lr_then_constant",
+          "seed": 456,
+          "selection": "fixed_final_epoch",
+          "warmup_steps": 200,
+          "weight_decay": 1e-07
+        },
+        "wandb": {
+          "mode": "disabled"
+        }
+      },
+      "file": "control/registered-configs/C3-MNIST-CNN-456.json"
+    },
+    "C4-MAZE-QUADRATIC-123": {
+      "canonical_sha256": "5f7b04835bc32b012a5e2d5e12e2b1512c3c95343ac7d8ac97a77a46178f723e",
+      "config": {
+        "data": {
+          "dir": "/data/train/maze_std3_19px_10k",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "cg_iters": 5,
+          "comm_norm_type": "layernorm",
+          "d_e": 5,
+          "d_v": 10,
+          "dec_hidden_dim": 256,
+          "decoder_arch": "mlp_concat_v2",
+          "enc_hidden_dim": 256,
+          "encoder_arch": "mlp_v2",
+          "gamma": 5.0,
+          "lora_init_style": "standard",
+          "lora_rank": 4,
+          "num_classes": 6,
+          "num_directions": 8,
+          "objective_mode": "quadratic",
+          "rho_init": 0.25,
+          "rm_init": "orthonormal",
+          "rm_mode": "context",
+          "rm_sharing": "directional",
+          "tikhonov_eps": 1e-05,
+          "x_solver": "diagonal_prox",
+          "z_mode": "prox",
+          "z_solver": "unrolled_cg"
+        },
+        "model_type": "sheaf",
+        "task": "maze",
+        "task_cfg": {
+          "connectivity": 8,
+          "num_classes": 6,
+          "patch_size": 3,
+          "stride": 2
+        },
+        "training": {
+          "K_eval": 100,
+          "K_train": 40,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 50,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 4,
+          "lr": 0.0003,
+          "mpnn_eval_rounds": 100,
+          "mpnn_train_rounds": 40,
+          "seed": 123,
+          "train_iters_dist": "uniform",
+          "train_iters_min": 15,
+          "val_interval": 5,
+          "warmup_steps": 200,
+          "weight_decay": 1e-06
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C4-MAZE-QUADRATIC-123.json"
+    },
+    "C4-MAZE-QUADRATIC-42": {
+      "canonical_sha256": "87eb0690dbe06c6c70044866181311c9f2c0f7f724e75063464c501c3ef533db",
+      "config": {
+        "data": {
+          "dir": "/data/train/maze_std3_19px_10k",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "cg_iters": 5,
+          "comm_norm_type": "layernorm",
+          "d_e": 5,
+          "d_v": 10,
+          "dec_hidden_dim": 256,
+          "decoder_arch": "mlp_concat_v2",
+          "enc_hidden_dim": 256,
+          "encoder_arch": "mlp_v2",
+          "gamma": 5.0,
+          "lora_init_style": "standard",
+          "lora_rank": 4,
+          "num_classes": 6,
+          "num_directions": 8,
+          "objective_mode": "quadratic",
+          "rho_init": 0.25,
+          "rm_init": "orthonormal",
+          "rm_mode": "context",
+          "rm_sharing": "directional",
+          "tikhonov_eps": 1e-05,
+          "x_solver": "diagonal_prox",
+          "z_mode": "prox",
+          "z_solver": "unrolled_cg"
+        },
+        "model_type": "sheaf",
+        "task": "maze",
+        "task_cfg": {
+          "connectivity": 8,
+          "num_classes": 6,
+          "patch_size": 3,
+          "stride": 2
+        },
+        "training": {
+          "K_eval": 100,
+          "K_train": 40,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 50,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 4,
+          "lr": 0.0003,
+          "mpnn_eval_rounds": 100,
+          "mpnn_train_rounds": 40,
+          "seed": 42,
+          "train_iters_dist": "uniform",
+          "train_iters_min": 15,
+          "val_interval": 5,
+          "warmup_steps": 200,
+          "weight_decay": 1e-06
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C4-MAZE-QUADRATIC-42.json"
+    },
+    "C4-MAZE-QUADRATIC-456": {
+      "canonical_sha256": "14a74656730c7fcc84be1e1cbda241310e68a92cc34f714820b7a5f32f18997e",
+      "config": {
+        "data": {
+          "dir": "/data/train/maze_std3_19px_10k",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "cg_iters": 5,
+          "comm_norm_type": "layernorm",
+          "d_e": 5,
+          "d_v": 10,
+          "dec_hidden_dim": 256,
+          "decoder_arch": "mlp_concat_v2",
+          "enc_hidden_dim": 256,
+          "encoder_arch": "mlp_v2",
+          "gamma": 5.0,
+          "lora_init_style": "standard",
+          "lora_rank": 4,
+          "num_classes": 6,
+          "num_directions": 8,
+          "objective_mode": "quadratic",
+          "rho_init": 0.25,
+          "rm_init": "orthonormal",
+          "rm_mode": "context",
+          "rm_sharing": "directional",
+          "tikhonov_eps": 1e-05,
+          "x_solver": "diagonal_prox",
+          "z_mode": "prox",
+          "z_solver": "unrolled_cg"
+        },
+        "model_type": "sheaf",
+        "task": "maze",
+        "task_cfg": {
+          "connectivity": 8,
+          "num_classes": 6,
+          "patch_size": 3,
+          "stride": 2
+        },
+        "training": {
+          "K_eval": 100,
+          "K_train": 40,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 50,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 4,
+          "lr": 0.0003,
+          "mpnn_eval_rounds": 100,
+          "mpnn_train_rounds": 40,
+          "seed": 456,
+          "train_iters_dist": "uniform",
+          "train_iters_min": 15,
+          "val_interval": 5,
+          "warmup_steps": 200,
+          "weight_decay": 1e-06
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C4-MAZE-QUADRATIC-456.json"
+    },
+    "C4-SUD-IDENTITY-123": {
+      "canonical_sha256": "3bbb5dec4ca83cbab0379208b94d19b570eb97e2e411259208734c7467ef06ef",
+      "config": {
+        "data": {
+          "dir": "/data/train/sudoku_easy",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "cg_iters": 5,
+          "comm_norm_type": "layernorm",
+          "d_e": 32,
+          "d_v": 288,
+          "dec_hidden_dims": [
+            256
+          ],
+          "decoder_arch": "sudoku",
+          "enc_d_model": 128,
+          "enc_num_blocks": 2,
+          "encoder_arch": "sudoku",
+          "gamma": 2.0,
+          "num_classes": 10,
+          "num_directions": 9,
+          "objective_mode": "non_negative",
+          "rho_init": 0.25,
+          "rm_constant": true,
+          "rm_init": "identity",
+          "rm_mode": "fixed",
+          "rm_sharing": "sudoku",
+          "x_solver": "diagonal_prox",
+          "z_mode": "prox",
+          "z_solver": "unrolled_cg"
+        },
+        "model_type": "sheaf",
+        "task": "sudoku",
+        "task_cfg": {},
+        "training": {
+          "K_eval": 50,
+          "K_train": 20,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 10,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 2,
+          "lr": 0.0017,
+          "mpnn_eval_rounds": 100,
+          "mpnn_train_rounds": 40,
+          "seed": 123,
+          "train_iters_dist": "fixed",
+          "train_iters_min": 15,
+          "val_interval": 1,
+          "warmup_steps": 200,
+          "weight_decay": 1e-07
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C4-SUD-IDENTITY-123.json"
+    },
+    "C4-SUD-IDENTITY-42": {
+      "canonical_sha256": "d6af26f0bfbcb23770bcd838ee12b937401c2dcc060dff601ff32de262e70f85",
+      "config": {
+        "data": {
+          "dir": "/data/train/sudoku_easy",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "cg_iters": 5,
+          "comm_norm_type": "layernorm",
+          "d_e": 32,
+          "d_v": 288,
+          "dec_hidden_dims": [
+            256
+          ],
+          "decoder_arch": "sudoku",
+          "enc_d_model": 128,
+          "enc_num_blocks": 2,
+          "encoder_arch": "sudoku",
+          "gamma": 2.0,
+          "num_classes": 10,
+          "num_directions": 9,
+          "objective_mode": "non_negative",
+          "rho_init": 0.25,
+          "rm_constant": true,
+          "rm_init": "identity",
+          "rm_mode": "fixed",
+          "rm_sharing": "sudoku",
+          "x_solver": "diagonal_prox",
+          "z_mode": "prox",
+          "z_solver": "unrolled_cg"
+        },
+        "model_type": "sheaf",
+        "task": "sudoku",
+        "task_cfg": {},
+        "training": {
+          "K_eval": 50,
+          "K_train": 20,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 10,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 2,
+          "lr": 0.0017,
+          "mpnn_eval_rounds": 100,
+          "mpnn_train_rounds": 40,
+          "seed": 42,
+          "train_iters_dist": "fixed",
+          "train_iters_min": 15,
+          "val_interval": 1,
+          "warmup_steps": 200,
+          "weight_decay": 1e-07
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C4-SUD-IDENTITY-42.json"
+    },
+    "C4-SUD-IDENTITY-456": {
+      "canonical_sha256": "265179cbf9101405f1b04175bc3d247a719ceb8a415d11b84345a240365cbd49",
+      "config": {
+        "data": {
+          "dir": "/data/train/sudoku_easy",
+          "loader": "puzzle",
+          "train_split": "train",
+          "val_splits": []
+        },
+        "dtype": "float32",
+        "model": {
+          "cg_iters": 5,
+          "comm_norm_type": "layernorm",
+          "d_e": 32,
+          "d_v": 288,
+          "dec_hidden_dims": [
+            256
+          ],
+          "decoder_arch": "sudoku",
+          "enc_d_model": 128,
+          "enc_num_blocks": 2,
+          "encoder_arch": "sudoku",
+          "gamma": 2.0,
+          "num_classes": 10,
+          "num_directions": 9,
+          "objective_mode": "non_negative",
+          "rho_init": 0.25,
+          "rm_constant": true,
+          "rm_init": "identity",
+          "rm_mode": "fixed",
+          "rm_sharing": "sudoku",
+          "x_solver": "diagonal_prox",
+          "z_mode": "prox",
+          "z_solver": "unrolled_cg"
+        },
+        "model_type": "sheaf",
+        "task": "sudoku",
+        "task_cfg": {},
+        "training": {
+          "K_eval": 50,
+          "K_train": 20,
+          "batch_size": 128,
+          "ema_decay": 0.999,
+          "epochs": 10,
+          "exit_on_nan": true,
+          "grad_clip": 1.0,
+          "loss_window": 2,
+          "lr": 0.0017,
+          "mpnn_eval_rounds": 100,
+          "mpnn_train_rounds": 40,
+          "seed": 456,
+          "train_iters_dist": "fixed",
+          "train_iters_min": 15,
+          "val_interval": 1,
+          "warmup_steps": 200,
+          "weight_decay": 1e-07
+        },
+        "wandb": {
+          "entity": null,
+          "group": null,
+          "mode": "disabled",
+          "name": null,
+          "project": "sheaf-admm",
+          "tags": []
+        }
+      },
+      "file": "control/registered-configs/C4-SUD-IDENTITY-456.json"
+    }
+  },
+  "run_identities": [
+    "C1-SUD-MPNN225-42",
+    "C1-SUD-MPNN225-123",
+    "C1-SUD-MPNN225-456",
+    "C2-MAZE-MPNN84-42",
+    "C2-MAZE-MPNN84-123",
+    "C2-MAZE-MPNN84-456",
+    "C3-MNIST-CNN-42",
+    "C3-MNIST-CNN-123",
+    "C3-MNIST-CNN-456",
+    "C4-SUD-IDENTITY-42",
+    "C4-SUD-IDENTITY-123",
+    "C4-SUD-IDENTITY-456",
+    "C4-MAZE-QUADRATIC-42",
+    "C4-MAZE-QUADRATIC-123",
+    "C4-MAZE-QUADRATIC-456"
+  ],
+  "submission_limits": {
+    "all_returned_ids_max": 29,
+    "cpu_retry_ids": 1,
+    "cpu_returned_ids_max": 3,
+    "gpu_retry_ids": 3,
+    "gpu_returned_ids_max": 26,
+    "primary_cpu_ids": 2,
+    "primary_gpu_ids": 23,
+    "target_scientific_concurrency": 6
+  },
+  "title": "Learning Multi-Agent Coordination via Sheaf-ADMM",
+  "training_common": {
+    "batch_size": 128,
+    "dtype": "float32",
+    "early_stopping": false,
+    "ema_decay": 0.999,
+    "evaluation_parameters": "EMA",
+    "global_grad_clip": 1.0,
+    "jax_default_matmul_precision": "highest",
+    "optimizer": "AdamW",
+    "schedule": "linear_to_task_lr_then_constant",
+    "selection": "fixed_final_epoch",
+    "training_mount_content": [
+      "registered_task_train_split"
+    ],
+    "validation_selection": false,
+    "validation_splits": [],
+    "warmup_steps": 200
+  },
+  "training_families": {
+    "C1-SUD-MPNN225": {
+      "base": "sudoku_mpnn",
+      "data": {
+        "dir": "datasets/sudoku_easy",
+        "loader": "puzzle",
+        "train_split": "train",
+        "val_splits": []
+      },
+      "model": {
+        "comm_norm_type": "layernorm",
+        "d_e": 32,
+        "d_v": 225,
+        "dec_hidden_dims": [
+          256
+        ],
+        "decoder_arch": "sudoku",
+        "enc_d_model": 128,
+        "enc_num_blocks": 2,
+        "encoder_arch": "sudoku",
+        "mpnn_aggregation": "max",
+        "mpnn_edge_type_mode": "slot",
+        "mpnn_graph_readout": "per_node",
+        "mpnn_message_dim": 32,
+        "num_classes": 10,
+        "num_directions": 9
+      },
+      "model_type": "mpnn",
+      "paper_row_reconstruction": true,
+      "seeds": [
+        42,
+        123,
+        456
+      ],
+      "task": "sudoku",
+      "task_cfg": {},
+      "training": {
+        "epochs": 10,
+        "lr": 0.0017,
+        "mpnn_eval_rounds": 50,
+        "mpnn_train_rounds": 20,
+        "weight_decay": 1e-07
+      }
+    },
+    "C2-MAZE-MPNN84": {
+      "base": "maze_mpnn",
+      "data": {
+        "dir": "datasets/maze_std3_19px_10k",
+        "loader": "puzzle",
+        "train_split": "train",
+        "val_splits": []
+      },
+      "model": {
+        "comm_norm_type": "layernorm",
+        "d_e": 42,
+        "d_v": 84,
+        "dec_hidden_dim": 256,
+        "decoder_arch": "mlp_concat_v2",
+        "enc_hidden_dim": 256,
+        "encoder_arch": "mlp_v2",
+        "mpnn_aggregation": "max",
+        "mpnn_edge_type_mode": "spatial",
+        "mpnn_graph_readout": "per_node",
+        "mpnn_message_dim": 42,
+        "num_classes": 6,
+        "num_directions": 8
+      },
+      "model_type": "mpnn",
+      "seeds": [
+        42,
+        123,
+        456
+      ],
+      "task": "maze",
+      "task_cfg": {
+        "connectivity": 8,
+        "num_classes": 6,
+        "patch_size": 3,
+        "stride": 2
+      },
+      "training": {
+        "epochs": 50,
+        "lr": 0.0003,
+        "mpnn_eval_rounds": 100,
+        "mpnn_train_rounds": 40,
+        "train_round_distribution": "fixed",
+        "weight_decay": 1e-06
+      }
+    },
+    "C3-MNIST-CNN": {
+      "data": {
+        "augmentation": false,
+        "input_range": [
+          0,
+          1
+        ],
+        "normalization": false,
+        "val_splits": []
+      },
+      "model": {
+        "bias_init": "zeros",
+        "kernel_init": "glorot_uniform",
+        "layers": [
+          "conv3x3-1-32-same-relu",
+          "conv3x3-32-32-same-relu",
+          "maxpool2x2-stride2-valid",
+          "conv3x3-32-64-same-relu",
+          "conv3x3-64-64-same-relu",
+          "global-spatial-mean",
+          "dense64-10"
+        ],
+        "layout": "NHWC/HWIO/NHWC",
+        "parameter_count": 65642,
+        "post_pool_sizes": [
+          14,
+          30
+        ],
+        "pre_pool_sizes": [
+          28,
+          60
+        ]
+      },
+      "model_type": "mnist_cnn_repro",
+      "seeds": [
+        42,
+        123,
+        456
+      ],
+      "task": "mnist",
+      "training": {
+        "betas": [
+          0.9,
+          0.999
+        ],
+        "epoch_permutation": "fold_in(PRNGKey(seed),epoch)",
+        "epochs": 20,
+        "epsilon": 1e-08,
+        "examples": 60000,
+        "final_batch": "pad_to_128_mask_normalize",
+        "kernel_only_weight_decay": 1e-07,
+        "loss": "mean_sparse_categorical_cross_entropy",
+        "lr": 0.001
+      }
+    },
+    "C4-MAZE-QUADRATIC": {
+      "base": "maze_sheaf",
+      "data": {
+        "dir": "datasets/maze_std3_19px_10k",
+        "loader": "puzzle",
+        "train_split": "train",
+        "val_splits": []
+      },
+      "forbidden_heads": [
+        "l1",
+        "lower_bound",
+        "upper_bound"
+      ],
+      "heads": [
+        "positive_q_diag",
+        "q"
+      ],
+      "model": {
+        "cg_iters": 5,
+        "comm_norm_type": "layernorm",
+        "d_e": 5,
+        "d_v": 10,
+        "dec_hidden_dim": 256,
+        "decoder_arch": "mlp_concat_v2",
+        "enc_hidden_dim": 256,
+        "encoder_arch": "mlp_v2",
+        "gamma": 5,
+        "lora_init_style": "standard",
+        "lora_rank": 4,
+        "num_classes": 6,
+        "num_directions": 8,
+        "objective_mode": "quadratic",
+        "rho_init": 0.25,
+        "rm_init": "orthonormal",
+        "rm_mode": "context",
+        "rm_sharing": "directional",
+        "tikhonov_eps": 1e-05,
+        "x_solver": "diagonal_prox",
+        "z_mode": "prox",
+        "z_solver": "unrolled_cg"
+      },
+      "model_type": "sheaf",
+      "overrides": {
+        "data.val_splits": [],
+        "model.objective_mode": "quadratic"
+      },
+      "seeds": [
+        42,
+        123,
+        456
+      ],
+      "task": "maze",
+      "task_cfg": {
+        "connectivity": 8,
+        "num_classes": 6,
+        "patch_size": 3,
+        "stride": 2
+      },
+      "training": {
+        "K_eval": 100,
+        "K_train": 40,
+        "epochs": 50,
+        "loss_window": 4,
+        "lr": 0.0003,
+        "train_K_distribution": "uniform_inclusive_15_40",
+        "train_iters_min": 15,
+        "weight_decay": 1e-06
+      }
+    },
+    "C4-SUD-IDENTITY": {
+      "base": "sudoku_sheaf",
+      "constant_map": "F=[I_32,0,...,0] for every slot and endpoint",
+      "data": {
+        "dir": "datasets/sudoku_easy",
+        "loader": "puzzle",
+        "train_split": "train",
+        "val_splits": []
+      },
+      "model": {
+        "cg_iters": 5,
+        "comm_norm_type": "layernorm",
+        "d_e": 32,
+        "d_v": 288,
+        "dec_hidden_dims": [
+          256
+        ],
+        "decoder_arch": "sudoku",
+        "enc_d_model": 128,
+        "enc_num_blocks": 2,
+        "encoder_arch": "sudoku",
+        "gamma": 2.0,
+        "num_classes": 10,
+        "num_directions": 9,
+        "objective_mode": "non_negative",
+        "rho_init": 0.25,
+        "rm_constant": true,
+        "rm_init": "identity",
+        "rm_mode": "fixed",
+        "rm_sharing": "sudoku",
+        "x_solver": "diagonal_prox",
+        "z_mode": "prox",
+        "z_solver": "unrolled_cg"
+      },
+      "model_type": "sheaf",
+      "overrides": {
+        "data.val_splits": [],
+        "model.rm_constant": true,
+        "model.rm_init": "identity"
+      },
+      "pairing_requirement": "control and intervention common leaves and counters bit-identical before replacement",
+      "parameter_tree_requirement": "no restriction-map leaf",
+      "seeds": [
+        42,
+        123,
+        456
+      ],
+      "task": "sudoku",
+      "task_cfg": {},
+      "training": {
+        "K_eval": 50,
+        "K_train": 20,
+        "epochs": 10,
+        "loss_window": 2,
+        "lr": 0.0017,
+        "train_iters_dist": "fixed",
+        "weight_decay": 1e-07
+      }
+    }
+  }
+}
diff --git a/assets/fig2.png b/assets/fig2.png
new file mode 100644
index 0000000000000000000000000000000000000000..59ad01a9b53561987e2867cd8426ecb26a3a473e
--- /dev/null
+++ b/assets/fig2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad817fb7e154e29969aec384e599c2cd02d0209575392f69af34bc4b901260e1
+size 284486
diff --git a/configs/config.yaml b/configs/config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..bfca3317cd73781dc24e6304e77b44d82e174eb7
--- /dev/null
+++ b/configs/config.yaml
@@ -0,0 +1,52 @@
+# Base config. Shared optimization settings live here (the paper's shared HPs);
+# per-task architecture + solver settings come from configs/experiment/*.yaml,
+# selected with `+experiment=<name>`.
+defaults:
+  - _self_
+
+task: maze            # maze | mnist | sudoku  (selects the task hook)
+model_type: sheaf     # sheaf | mpnn
+dtype: float32        # registered reproduction runs forbid mixed precision
+
+wandb:
+  project: sheaf-admm
+  entity: null        # null -> your default wandb entity
+  name: null          # null -> wandb auto-name
+  group: null         # e.g. group seeds of one experiment together
+  tags: []
+  mode: disabled      # online | offline | disabled
+
+training:
+  seed: 42            # paper sweeps seeds {42, 123, 456}
+  lr: 3.0e-4
+  weight_decay: 1.0e-6
+  epochs: 50
+  batch_size: 128
+  warmup_steps: 200   # linear warmup -> constant LR
+  grad_clip: 1.0      # global-norm clip
+  ema_decay: 0.999    # EMA of params, used at eval
+  exit_on_nan: true
+  val_interval: 5
+
+  # ADMM horizon (Sheaf): K_train iterations at train, K_eval at eval.
+  K_train: 40
+  K_eval: 100
+  loss_window: 4              # average CE over the final w iterates
+  train_iters_dist: fixed     # fixed | uniform (Maze resamples K ~ U[train_iters_min, K_train])
+  train_iters_min: 15
+
+  # MPNN baseline message-passing rounds (the K analog for the recurrent MPNN).
+  mpnn_train_rounds: 40
+  mpnn_eval_rounds: 100
+
+data:
+  dir: ???            # set per experiment
+  train_split: train
+  val_splits: [test]
+  loader: puzzle      # puzzle (maze/sudoku) | image (mnist)
+
+# kwargs forwarded to the task hook (sheaf_admm.training.make_task)
+task_cfg: {}
+
+# sheaf_admm.models.ModelConfig fields (set per experiment)
+model: {}
diff --git a/configs/experiment/maze_mpnn.yaml b/configs/experiment/maze_mpnn.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5c8e13648b7ccbd23a90e0556ac4dcf5a96d5d58
--- /dev/null
+++ b/configs/experiment/maze_mpnn.yaml
@@ -0,0 +1,40 @@
+# @package _global_
+# Table 1 baseline: recurrent-MPNN, parameter-matched (d_v=84, ~182K), max aggregation.
+# (CM variant: set model.d_v=10, model.d_e=5, model.mpnn_message_dim=5 -> ~49K.)
+task: maze
+model_type: mpnn
+
+training:
+  lr: 3.0e-4
+  weight_decay: 1.0e-6
+  epochs: 50
+  mpnn_train_rounds: 40
+  mpnn_eval_rounds: 100
+  val_interval: 5
+
+data:
+  dir: datasets/maze_std3_19px_10k
+  train_split: train
+  val_splits: [test, test_ood_2x, test_ood_2xW, test_ood_4x, test_ood_4xW]
+  loader: puzzle
+
+task_cfg:
+  patch_size: 3
+  stride: 2
+  connectivity: 8
+  num_classes: 6
+
+model:
+  num_classes: 6
+  d_v: 84
+  d_e: 42
+  encoder_arch: mlp_v2
+  enc_hidden_dim: 256
+  comm_norm_type: layernorm
+  decoder_arch: mlp_concat_v2
+  dec_hidden_dim: 256
+  mpnn_message_dim: 42
+  mpnn_aggregation: max          # the strongest aggregation in the sweep
+  mpnn_edge_type_mode: spatial   # 8 grid directions
+  num_directions: 8
+  mpnn_graph_readout: per_node
diff --git a/configs/experiment/maze_sheaf.yaml b/configs/experiment/maze_sheaf.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..41acd595ec6d748cd30482e1518f677ec6c1ef73
--- /dev/null
+++ b/configs/experiment/maze_sheaf.yaml
@@ -0,0 +1,51 @@
+# @package _global_
+# Table 1 anchor: Sheaf-ADMM maze (d_v=10, ~182K params -> 99.9 / 98.1 / 4.5).
+task: maze
+model_type: sheaf
+
+training:
+  lr: 3.0e-4
+  weight_decay: 1.0e-6
+  epochs: 50
+  K_train: 40
+  K_eval: 100
+  loss_window: 4
+  train_iters_dist: uniform   # K ~ U[15, 40] per step
+  train_iters_min: 15
+  val_interval: 5
+
+data:
+  dir: datasets/maze_std3_19px_10k
+  train_split: train
+  val_splits: [test, test_ood_2x, test_ood_2xW, test_ood_4x, test_ood_4xW]
+  loader: puzzle
+
+task_cfg:
+  patch_size: 3
+  stride: 2
+  connectivity: 8
+  num_classes: 6
+
+model:
+  num_classes: 6
+  d_v: 10
+  d_e: 5
+  encoder_arch: mlp_v2
+  enc_hidden_dim: 256
+  comm_norm_type: layernorm
+  objective_mode: l1box_diag        # closed-form L1 + box x-update
+  x_solver: diagonal_prox
+  z_solver: unrolled_cg
+  z_mode: prox                      # soft consensus
+  gamma: 5.0
+  cg_iters: 5
+  tikhonov_eps: 1.0e-5
+  rm_sharing: directional           # one base map per grid direction (8-way, see num_directions)
+  rm_init: orthonormal
+  rm_mode: context                  # LoRA-modulated restriction maps
+  lora_rank: 4
+  lora_init_style: standard
+  num_directions: 8
+  rho_init: 0.25
+  decoder_arch: mlp_concat_v2
+  dec_hidden_dim: 256
diff --git a/configs/experiment/mnist_mpnn.yaml b/configs/experiment/mnist_mpnn.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..86cedc77de38cd5f165c1d5259d9d3611899881c
--- /dev/null
+++ b/configs/experiment/mnist_mpnn.yaml
@@ -0,0 +1,39 @@
+# @package _global_
+# MNIST recurrent-MPNN baseline (graph-level mean-pool readout).
+task: mnist
+model_type: mpnn
+
+training:
+  lr: 1.0e-3
+  weight_decay: 1.0e-7
+  epochs: 20
+  mpnn_train_rounds: 20
+  mpnn_eval_rounds: 50
+  val_interval: 5
+
+data:
+  dir: datasets/mnist
+  train_split: train
+  val_splits: [test]
+  loader: image
+
+task_cfg:
+  patch_size: 3
+  stride: 3
+  connectivity: 8
+  num_classes: 10
+
+model:
+  num_classes: 10
+  d_v: 32
+  d_e: 24
+  encoder_arch: mlp
+  enc_hidden_dim: 256
+  comm_norm_type: layernorm
+  decoder_arch: classification
+  dec_hidden_dims: [128]
+  mpnn_message_dim: 24
+  mpnn_aggregation: mean
+  mpnn_edge_type_mode: spatial
+  num_directions: 8
+  mpnn_graph_readout: graph
diff --git a/configs/experiment/mnist_sheaf.yaml b/configs/experiment/mnist_sheaf.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..0dd73bb5e2eee7b0fc64229f9f0e7b04b021b7d4
--- /dev/null
+++ b/configs/experiment/mnist_sheaf.yaml
@@ -0,0 +1,52 @@
+# @package _global_
+# MNIST classification (clean ~98.5%): 28x28 image, non-overlapping 3x3 patches
+# (stride 3 -> 81 agents). Global (shared) restriction map, hard consensus (Fz=0).
+task: mnist
+model_type: sheaf
+
+training:
+  lr: 1.0e-3
+  weight_decay: 1.0e-7
+  epochs: 20
+  K_train: 20
+  K_eval: 100
+  loss_window: 2
+  train_iters_dist: fixed
+  val_interval: 5
+
+data:
+  dir: datasets/mnist
+  train_split: train
+  val_splits: [test]
+  loader: image
+
+task_cfg:
+  patch_size: 3
+  stride: 3          # paper Table 4 stride
+  connectivity: 8
+  num_classes: 10
+
+model:
+  num_classes: 10
+  d_v: 32
+  d_e: 24
+  encoder_arch: mlp
+  enc_hidden_dim: 256
+  comm_norm_type: layernorm
+  objective_mode: lasso
+  l1_weight: 0.006337180166370117
+  x_solver: diagonal_prox
+  z_solver: unrolled_cg
+  z_mode: project          # hard consensus (Fz = 0)
+  cg_iters: 5
+  tikhonov_eps: 1.0e-5
+  rm_sharing: global       # one shared restriction map
+  rm_init: orthonormal
+  rm_mode: context
+  lora_rank: 8
+  lora_init_style: legacy
+  num_directions: 8
+  rho_init: 0.12
+  decoder_arch: classification
+  dec_linear_head: true
+  dec_readout_mode: x_only
diff --git a/configs/experiment/sudoku_mpnn.yaml b/configs/experiment/sudoku_mpnn.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..aa60a3167ac7456f3e6dfe349d71e1f544b4d326
--- /dev/null
+++ b/configs/experiment/sudoku_mpnn.yaml
@@ -0,0 +1,36 @@
+# @package _global_
+# Recurrent-MPNN Sudoku baseline.
+task: sudoku
+model_type: mpnn
+
+training:
+  lr: 3.0e-4
+  weight_decay: 1.0e-7
+  epochs: 5
+  mpnn_train_rounds: 20
+  mpnn_eval_rounds: 50
+  val_interval: 1
+
+data:
+  dir: datasets/sudoku_easy
+  train_split: train
+  val_splits: [test_hard]
+  loader: puzzle
+
+task_cfg: {}
+
+model:
+  num_classes: 10
+  d_v: 504
+  d_e: 32
+  encoder_arch: sudoku
+  enc_d_model: 128
+  enc_num_blocks: 2
+  comm_norm_type: layernorm
+  decoder_arch: sudoku
+  dec_hidden_dims: [256]
+  mpnn_message_dim: 32
+  mpnn_aggregation: max
+  mpnn_edge_type_mode: slot       # 9 shared-cell slots
+  num_directions: 9
+  mpnn_graph_readout: per_node
diff --git a/configs/experiment/sudoku_sheaf.yaml b/configs/experiment/sudoku_sheaf.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3b388e15c74b6ed75a300a40c0e4f214d3fa148c
--- /dev/null
+++ b/configs/experiment/sudoku_sheaf.yaml
@@ -0,0 +1,44 @@
+# @package _global_
+# Sheaf-ADMM Sudoku with fixed restriction maps.
+task: sudoku
+model_type: sheaf
+
+training:
+  lr: 1.7e-3
+  weight_decay: 1.0e-7
+  epochs: 10
+  K_train: 20
+  K_eval: 50
+  loss_window: 2
+  train_iters_dist: fixed
+  val_interval: 1
+
+data:
+  dir: datasets/sudoku_easy
+  train_split: train
+  val_splits: [test_hard]
+  loader: puzzle
+
+task_cfg: {}   # 27 row/col/box agents are derived from the multigraph
+
+model:
+  num_classes: 10
+  d_v: 288               # 9 cells x 32-dim blocks
+  d_e: 32
+  encoder_arch: sudoku
+  enc_d_model: 128
+  enc_num_blocks: 2
+  comm_norm_type: layernorm
+  objective_mode: non_negative      # closed-form x = max((rho(z-y)-q)/(D+rho), 0)
+  x_solver: diagonal_prox
+  z_solver: unrolled_cg
+  z_mode: prox
+  gamma: 2.0
+  cg_iters: 5
+  rm_sharing: sudoku                # 9 base maps = selectors onto 9 disjoint 32-d blocks
+  rm_init: soft_slice
+  rm_mode: fixed
+  num_directions: 9
+  rho_init: 0.25
+  decoder_arch: sudoku
+  dec_hidden_dims: [256]
diff --git a/configs/experiment/sudoku_sheaf_lora.yaml b/configs/experiment/sudoku_sheaf_lora.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..221a6c2465f5f31799381fcf352845d872ba7a57
--- /dev/null
+++ b/configs/experiment/sudoku_sheaf_lora.yaml
@@ -0,0 +1,46 @@
+# @package _global_
+# Sheaf-ADMM Sudoku with LoRA-modulated restriction maps.
+task: sudoku
+model_type: sheaf
+
+training:
+  lr: 1.7e-3
+  weight_decay: 1.0e-7
+  epochs: 10
+  K_train: 20
+  K_eval: 50
+  loss_window: 2
+  train_iters_dist: fixed
+  val_interval: 1
+
+data:
+  dir: datasets/sudoku_easy
+  train_split: train
+  val_splits: [test_hard]
+  loader: puzzle
+
+task_cfg: {}
+
+model:
+  num_classes: 10
+  d_v: 288
+  d_e: 32
+  encoder_arch: sudoku
+  enc_d_model: 128
+  enc_num_blocks: 2
+  comm_norm_type: layernorm
+  objective_mode: non_negative
+  x_solver: diagonal_prox
+  z_solver: unrolled_cg
+  z_mode: prox
+  gamma: 2.0
+  cg_iters: 5
+  rm_sharing: sudoku
+  rm_init: soft_slice
+  rm_mode: context          # LoRA modulation on
+  lora_rank: 4
+  lora_init_style: standard
+  num_directions: 9
+  rho_init: 0.25
+  decoder_arch: sudoku
+  dec_hidden_dims: [256]
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b6f7f6a3e0a8c57c298e6108daffcda5e9918f92
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,71 @@
+[project]
+name = "sheaf-admm"
+version = "0.1.0"
+description = "Learning multi-agent coordination via sheaf-constrained ADMM (JAX/Flax reference implementation)."
+readme = "README.md"
+requires-python = ">=3.12,<3.13"
+license = { text = "Apache-2.0" }
+authors = [
+    { name = "Jeffrey Seely" },
+    { name = "Bartłomiej Cupiał" },
+    { name = "Llion Jones" },
+]
+dependencies = [
+    "jax==0.10.1; sys_platform != 'linux'",
+    "jax[cuda12]==0.10.1; sys_platform == 'linux'",
+    "flax==0.12.7",
+    "optax==0.2.8",
+    "numpy==2.4.6",
+    "hydra-core==1.3.2",
+    "omegaconf==2.3.0",
+    # dataset construction — required to build MNIST / Sudoku / maze locally
+    "ml-datasets==0.2.1",
+    "datasets==4.8.5",
+    "huggingface-hub==1.17.0",
+    # figures / artifacts
+    "matplotlib==3.10.9",
+    "pillow==12.2.0",
+    # experiment tracking
+    "wandb==0.27.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sheaf_admm"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/assets",
+    "/configs",
+    "/scripts",
+    "/src",
+    "/tests",
+    "/LICENSE",
+    "/README.md",
+    "/pyproject.toml",
+    "/uv.lock",
+]
+
+[dependency-groups]
+dev = [
+    "pytest==9.0.3",
+    "ruff==0.15.15",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "slow: end-to-end tests that train a tiny model (deselect with -m 'not slow')",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+# Keep math unicode (ρ, σ, γ, η, λ) — they read better than ASCII in this codebase.
+select = ["E", "F", "I", "UP", "B", "SIM"]
+ignore = ["E741", "RUF002", "RUF003", "B008"]
diff --git a/scripts/aggregate_attempts.py b/scripts/aggregate_attempts.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad8d266d7132c044c3f6e5b499a84801a763e6cc
--- /dev/null
+++ b/scripts/aggregate_attempts.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""Accept a complete attempt or verify the complete accepted identity set."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.aggregation import accept_attempt, load_complete_units
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--registry", type=Path, required=True)
+    sub = parser.add_subparsers(dest="action", required=True)
+    accept = sub.add_parser("accept")
+    accept.add_argument("--logical-id", required=True)
+    accept.add_argument("--attempt-id", required=True)
+    accept.add_argument("--prefix", type=Path, required=True)
+    verify = sub.add_parser("verify")
+    verify.add_argument("--required-json", type=Path, required=True)
+    args = parser.parse_args()
+    if args.action == "accept":
+        row = accept_attempt(
+            args.registry,
+            logical_id=args.logical_id,
+            attempt_id=args.attempt_id,
+            prefix=args.prefix,
+        )
+        print(json.dumps(row, sort_keys=True))
+    else:
+        required = set(json.loads(args.required_json.read_text()))
+        print(json.dumps(load_complete_units(args.registry, required), sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/build_preupload_privacy.py b/scripts/build_preupload_privacy.py
new file mode 100644
index 0000000000000000000000000000000000000000..f53c2c0749a6b58ec0d3f3b47334185d0526c21d
--- /dev/null
+++ b/scripts/build_preupload_privacy.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Assemble the exact multi-scope PRE_UPLOAD_PRIVACY receipt, failing incomplete."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.hashing import atomic_write_json, compact_json_bytes, sha256_bytes, sha256_file
+from repro_control.privacy import SCANNER_VERSION, scan_paths
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--checkout", type=Path, required=True)
+    parser.add_argument("--package-manifest", type=Path, required=True)
+    parser.add_argument("--image-contract", type=Path, required=True)
+    parser.add_argument("--intended-remote-map", type=Path, required=True)
+    parser.add_argument("--output", type=Path, default=Path("PRE_UPLOAD_PRIVACY.json"))
+    args = parser.parse_args()
+    checkout = args.checkout.resolve()
+    tracked = subprocess.run(
+        ["git", "ls-files", "-z"],
+        cwd=checkout,
+        check=True,
+        capture_output=True,
+    ).stdout.split(b"\0")
+    tracked_paths = [checkout / raw.decode() for raw in tracked if raw]
+    source = scan_paths(
+        tracked_paths,
+        relative_to=checkout,
+        intended_remote_map=json.loads(args.intended_remote_map.read_text()),
+    )
+    object_lines = subprocess.run(
+        ["git", "rev-list", "--objects", "--all"],
+        cwd=checkout,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.splitlines()
+    git_objects = sorted(line.split()[0] for line in object_lines if line)
+    trackio = checkout / ".trackio"
+    trackio_scan = (
+        scan_paths([trackio], relative_to=checkout, intended_remote_map={})
+        if trackio.is_dir()
+        else None
+    )
+    image = json.loads(args.image_contract.read_text())
+    package_manifest = json.loads(args.package_manifest.read_text())
+    blockers = []
+    if trackio_scan is None:
+        blockers.append(".trackio scaffold does not exist")
+    if not image.get("resolved_and_read_back"):
+        blockers.append("immutable image config/history/layers are unresolved")
+    if source["findings"]:
+        blockers.append("source privacy findings exist")
+    if trackio_scan and trackio_scan["findings"]:
+        blockers.append(".trackio privacy findings exist")
+    receipt = {
+        "format": 1,
+        "scanner_version": SCANNER_VERSION,
+        "rules": source["rules"],
+        "source": source,
+        "git_object_ids": git_objects,
+        "git_object_set_sha256": sha256_bytes(compact_json_bytes(git_objects)),
+        "trackio": trackio_scan,
+        "image_contract_sha256": sha256_file(args.image_contract),
+        "image": image,
+        "private_input_manifest_sha256": sha256_file(args.package_manifest),
+        "private_input_payload_root_sha256": package_manifest["payload_root_sha256"],
+        "intended_remote_map_sha256": sha256_file(args.intended_remote_map),
+        "complete": not blockers,
+        "blockers": blockers,
+        "exit_code": 0 if not blockers else 2,
+    }
+    atomic_write_json(args.output, receipt)
+    print(json.dumps({"complete": receipt["complete"], "blockers": blockers}))
+    return receipt["exit_code"]
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/build_registered_data.py b/scripts/build_registered_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cabdb20bd9fd2d174b750952c5e7dcb3d39dda1
--- /dev/null
+++ b/scripts/build_registered_data.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Build sealed MNIST mask banks or registered C5 long-path shards."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.data import (
+    build_mnist_mask_bank,
+    generate_c5_size,
+    write_mnist_mask_bank,
+)
+from repro_control.hashing import atomic_write_json
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    sub = parser.add_subparsers(dest="command", required=True)
+    masks = sub.add_parser("mnist-masks")
+    masks.add_argument("--dataset-revision", required=True)
+    masks.add_argument("--example-ids-json", type=Path, required=True)
+    masks.add_argument("--output", type=Path, required=True)
+    c5 = sub.add_parser("c5")
+    c5.add_argument("--size", type=int, required=True)
+    c5.add_argument("--training-identities-json", type=Path, required=True)
+    c5.add_argument("--examples", type=int, default=1000)
+    c5.add_argument("--output-npz", type=Path, required=True)
+    c5.add_argument("--output-manifest", type=Path, required=True)
+    args = parser.parse_args()
+    if args.command == "mnist-masks":
+        ids = json.loads(args.example_ids_json.read_text())
+        bank = build_mnist_mask_bank(args.dataset_revision, ids)
+        write_mnist_mask_bank(args.output, bank)
+        print(bank["bank_sha256"])
+        return 0
+    import numpy as np
+
+    identities = frozenset(json.loads(args.training_identities_json.read_text()))
+    arrays, manifest = generate_c5_size(
+        args.size,
+        training_identities=identities,
+        examples=args.examples,
+    )
+    args.output_npz.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(args.output_npz, **arrays)
+    atomic_write_json(args.output_manifest, manifest)
+    print(manifest["identity_root_sha256"])
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/evaluate_repro.py b/scripts/evaluate_repro.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a838490f6917a8cd5e27bbbc27c9516ac3adee7
--- /dev/null
+++ b/scripts/evaluate_repro.py
@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Run one fused verdict evaluator and seal its complete result units."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.archives import safe_extract_tar_gz
+from repro_control.artifacts import finalize_attempt, verify_read_back
+from repro_control.hashing import atomic_write_json, sha256_file
+from repro_control.heartbeat import heartbeat, marker
+from repro_control.runtime import (
+    assert_evaluation_isolated,
+    configure_scientific_runtime,
+    load_job_manifest,
+    require_control_freeze,
+    verify_science_spec,
+)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--science-spec", type=Path, required=True)
+    parser.add_argument("--job-manifest", type=Path, required=True)
+    parser.add_argument("--control-dir", type=Path, required=True)
+    parser.add_argument("--freeze-sha256", required=True)
+    parser.add_argument("--unit-manifest", type=Path)
+    parser.add_argument("--output-dir", type=Path)
+    parser.add_argument("--eval-archive", type=Path)
+    parser.add_argument("--eval-destination", type=Path, default=Path("/data/eval"))
+    parser.add_argument("--imports-archive", type=Path)
+    parser.add_argument("--imports-destination", type=Path, default=Path("/imports"))
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+    spec = verify_science_spec(args.science_spec)
+    manifest = load_job_manifest(args.job_manifest, freeze_sha256=args.freeze_sha256)
+    assert_evaluation_isolated(manifest)
+    if manifest["logical_id"] not in spec["evaluators"]:
+        raise SystemExit("unregistered evaluator logical identity")
+    require_control_freeze(
+        args.control_dir,
+        args.freeze_sha256,
+        manifest["science_spec_sha256"],
+    )
+    configure_scientific_runtime()
+    if args.dry_run:
+        print(
+            json.dumps(
+                {
+                    "contract_verified": True,
+                    "logical_id": manifest["logical_id"],
+                    "outcomes": {},
+                }
+            )
+        )
+        return 0
+    if args.unit_manifest is None or args.output_dir is None:
+        raise SystemExit("--unit-manifest and --output-dir are required for execution")
+    if sha256_file(args.unit_manifest) != manifest["hashes"]["config"]:
+        raise SystemExit("evaluator unit manifest hash mismatch")
+    args.output_dir.mkdir(parents=True, exist_ok=False)
+    if args.eval_archive:
+        safe_extract_tar_gz(args.eval_archive, args.eval_destination)
+    if args.imports_archive:
+        safe_extract_tar_gz(args.imports_archive, args.imports_destination)
+    marker("GPU_READY", manifest["logical_id"])
+    from repro_control.evaluation import evaluate_units
+
+    with heartbeat(f"SCIENTIFIC_EVAL:{manifest['logical_id']}"):
+        evaluate_units(args.unit_manifest, args.output_dir / "results.json")
+    atomic_write_json(
+        args.output_dir / "evaluation-receipt.json",
+        {
+            "format": 1,
+            "logical_id": manifest["logical_id"],
+            "attempt_id": manifest["attempt_id"],
+            "unit_manifest_sha256": sha256_file(args.unit_manifest),
+            "results_sha256": sha256_file(args.output_dir / "results.json"),
+            "outcomes": {},
+        },
+    )
+    finalize_attempt(
+        args.output_dir,
+        logical_id=manifest["logical_id"],
+        attempt_id=manifest["attempt_id"],
+        expected_outputs=manifest["expected_outputs"],
+    )
+    verify_read_back(
+        args.output_dir,
+        logical_id=manifest["logical_id"],
+        attempt_id=manifest["attempt_id"],
+    )
+    marker("DONE", f"{manifest['logical_id']} {manifest['attempt_id']}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/freeze_science_spec.py b/scripts/freeze_science_spec.py
new file mode 100644
index 0000000000000000000000000000000000000000..522a11af6b0efb077ae21fc0349ab75b2ee61300
--- /dev/null
+++ b/scripts/freeze_science_spec.py
@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Materialize exact registered configs and propagate the immutable science-spec hash."""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.configs import config_sha256, registered_config_for
+from repro_control.hashing import atomic_write_json, sha256_file
+
+SUDOKU_REVISION = "4d5aa527a9fb9aacca0b0d5b8b77d569fa9afcaa"
+TRACKIO_WHEEL_SHA256 = "277340507ac46c02c06900c1d680129bdb528223c8110b0b6bc9326bb9f0891d"
+BASE_IMAGE = (
+    "python:3.12-slim@"
+    "sha256:cab2dbf575e971934a81e4622f5aba17aa7929719bd7e31033a3a83b97fd0464"
+)
+IMAGE_SPACE_ID = "Mindcraft/sheaf-admm-icml2026-executor"
+
+
+def _replace_spec_hash(path: Path, old: str, new: str) -> None:
+    text = path.read_text()
+    if old not in text:
+        raise RuntimeError(f"old science-spec hash not present in {path}")
+    path.write_text(text.replace(old, new))
+
+
+def main() -> int:
+    root = Path(__file__).resolve().parents[1]
+    spec_path = root / "SCIENCE-SPEC.yaml"
+    old_hash = sha256_file(spec_path)
+    spec = json.loads(spec_path.read_text())
+    if spec.get("outcomes") != {} or len(spec.get("run_identities", [])) != 15:
+        raise RuntimeError("science spec is not in the pre-outcome fifteen-run state")
+    spec["authorities"].update(
+        {
+            "sudoku_dataset_revision": SUDOKU_REVISION,
+            "dependency_lock_sha256": sha256_file(root / "uv.lock"),
+            "trackio_wheel_sha256": TRACKIO_WHEEL_SHA256,
+            "base_image": BASE_IMAGE,
+            "execution_image_space": IMAGE_SPACE_ID,
+        }
+    )
+    spec["data_rules"]["sudoku"]["revision"] = SUDOKU_REVISION
+    registered = {}
+    config_root = root / "control" / "registered-configs"
+    for logical_id in spec["run_identities"]:
+        config = registered_config_for(root, logical_id)
+        digest = config_sha256(config)
+        atomic_write_json(config_root / f"{logical_id}.json", config)
+        if sha256_file(config_root / f"{logical_id}.json") == digest:
+            raise RuntimeError("file-byte hash must remain distinct from canonical config hash")
+        registered[logical_id] = {
+            "canonical_sha256": digest,
+            "file": f"control/registered-configs/{logical_id}.json",
+            "config": config,
+        }
+    spec["registered_configs"] = registered
+    atomic_write_json(spec_path, spec)
+    new_hash = sha256_file(spec_path)
+    if new_hash == old_hash:
+        raise RuntimeError("science spec did not change")
+
+    constants_path = root / "src" / "repro_control" / "constants.py"
+    constants = constants_path.read_text()
+    constants = re.sub(
+        r'SCIENCE_SPEC_SHA256 = "[0-9a-f]{64}"',
+        f'SCIENCE_SPEC_SHA256 = "{new_hash}"',
+        constants,
+        count=1,
+    )
+    constants_path.write_text(constants)
+    _replace_spec_hash(root / "Dockerfile", old_hash, new_hash)
+
+    image_contract_path = root / "IMAGE-SOURCE-CONTRACT.json"
+    image_contract = json.loads(image_contract_path.read_text())
+    image_contract.update(
+        base_image_digest=BASE_IMAGE.rsplit("@", 1)[1],
+        science_spec_sha256=new_hash,
+    )
+    atomic_write_json(image_contract_path, image_contract)
+
+    freeze_path = root / "control" / "SCIENCE-FREEZE.template.yaml"
+    freeze = json.loads(freeze_path.read_text())
+    freeze["science_spec_sha256"] = new_hash
+    atomic_write_json(freeze_path, freeze)
+
+    inventory_path = root / "PUBLICATION-INVENTORY.json"
+    inventory = json.loads(inventory_path.read_text())
+    image_rows = [
+        row for row in inventory["entries"] if row["asset_or_surface_type"] == "execution_image"
+    ]
+    if len(image_rows) != 1:
+        raise RuntimeError("publication inventory must have exactly one execution image row")
+    image_rows[0]["full_url_or_expected_repo"] = (
+        f"https://huggingface.co/spaces/{IMAGE_SPACE_ID}"
+    )
+    atomic_write_json(inventory_path, inventory)
+
+    status_path = root / "LOCAL-IMPLEMENTATION-STATUS.md"
+    if status_path.exists() and old_hash in status_path.read_text():
+        _replace_spec_hash(status_path, old_hash, new_hash)
+    print(
+        json.dumps(
+            {
+                "old_science_spec_sha256": old_hash,
+                "science_spec_sha256": new_hash,
+                "registered_config_count": len(registered),
+                "sudoku_revision": SUDOKU_REVISION,
+            },
+            sort_keys=True,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/import_data.py b/scripts/import_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..473d7b4399eb05fac0a71d65bcc11e011d899a43
--- /dev/null
+++ b/scripts/import_data.py
@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""Build and seal the private train/eval/import input archives on an HF CPU Job."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.archives import create_deterministic_tar_gz
+from repro_control.artifacts import finalize_attempt, verify_read_back
+from repro_control.checkpoints import load_neutral_checkpoint
+from repro_control.data import (
+    C5_SIZES,
+    build_mnist_mask_bank,
+    canonical_maze_identity,
+    generate_c5_size,
+    validate_smoke_fixture_registry,
+    write_mnist_mask_bank,
+    write_puzzle_split,
+)
+from repro_control.hashing import (
+    atomic_write_json,
+    canonical_root,
+    file_entry,
+    sha256_file,
+)
+from repro_control.heartbeat import heartbeat, marker
+from repro_control.runtime import load_job_manifest, verify_science_spec
+
+
+def _verify_handoff(handoff: Path, *, verify_checkpoints: bool) -> list[dict]:
+    package_manifest = json.loads((handoff / "PACKAGE-MANIFEST.json").read_text())
+    for row in package_manifest["entries"]:
+        path = handoff / row["path"]
+        if path.stat().st_size != row["bytes"] or sha256_file(path) != row["sha256"]:
+            raise SystemExit(f"handoff mismatch: {row['path']}")
+    imports = json.loads((handoff / "IMPORTS.json").read_text())
+    if len(imports) != 9:
+        raise SystemExit("IMPORTS.json must contain exactly nine rows")
+    validate_smoke_fixture_registry(handoff / "SMOKE-FIXTURES.json")
+    if verify_checkpoints:
+        for row in imports:
+            load_neutral_checkpoint(
+                handoff / "checkpoints" / row["neutral_alias"] / "checkpoint.pkl",
+                handoff / "configs" / f"{row['neutral_alias']}.json",
+                row,
+            )
+    return imports
+
+
+def _tree_manifest(root: Path) -> dict:
+    entries = [
+        file_entry(path, relative_to=root)
+        for path in sorted(root.rglob("*"))
+        if path.is_file()
+    ]
+    return {"format": 1, "entries": entries, "root_sha256": canonical_root(entries)}
+
+
+def _copy_split(source_dataset: Path, split: str, target_dataset: Path) -> None:
+    target_dataset.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(source_dataset / split, target_dataset / split)
+    for name in ("metadata.json", "config.json"):
+        source = source_dataset / name
+        if source.is_file():
+            shutil.copy2(source, target_dataset / name)
+
+
+def _maze_training_identities(dataset_root: Path) -> frozenset[str]:
+    import numpy as np
+
+    inputs = np.load(dataset_root / "train/all__inputs.npy", mmap_mode="r")
+    labels = np.load(dataset_root / "train/all__labels.npy", mmap_mode="r")
+    return frozenset(
+        canonical_maze_identity(input_row, label_row)
+        for input_row, label_row in zip(inputs, labels, strict=True)
+    )
+
+
+def _build_registered_inputs(
+    handoff: Path,
+    workspace: Path,
+    *,
+    sudoku_revision: str,
+) -> dict:
+    from sheaf_admm.data.build_maze import MazeConfig
+    from sheaf_admm.data.build_maze import build as build_maze
+    from sheaf_admm.data.build_mnist import MNISTConfig
+    from sheaf_admm.data.build_mnist import build as build_mnist
+    from sheaf_admm.data.build_sudoku import SudokuConfig
+    from sheaf_admm.data.build_sudoku import build as build_sudoku
+
+    build_root = workspace / "build"
+    maze_root = build_root / "maze_std3_19px_10k"
+    mnist_root = build_root / "mnist"
+    sudoku_root = build_root / "sudoku_easy"
+
+    marker("HEARTBEAT", "CPU_IMPORT:build-maze")
+    build_maze(
+        MazeConfig(
+            height=19,
+            width=19,
+            train_size=10_000,
+            test_size=1_000,
+            min_path_length=18,
+            train_augment=True,
+            test_augment=False,
+            seed=0,
+            output_dir=maze_root,
+        ),
+        ood_sizes=False,
+    )
+    marker("HEARTBEAT", "CPU_IMPORT:build-mnist")
+    build_mnist(
+        MNISTConfig(
+            padding=0,
+            seed=0,
+            normalize=True,
+            gen_robustness=False,
+            output_dir=mnist_root,
+        )
+    )
+    marker("HEARTBEAT", "CPU_IMPORT:build-sudoku")
+    build_sudoku(
+        SudokuConfig(
+            dataset_revision=sudoku_revision,
+            seed=0,
+            train_size=50_000,
+            test_size=2_000,
+            difficulty_max=2.0,
+            train_augment=True,
+            test_augment=False,
+            output_dir=sudoku_root,
+        )
+    )
+
+    train_root = workspace / "train"
+    eval_root = workspace / "eval"
+    imports_root = workspace / "imports"
+    _copy_split(maze_root, "train", train_root / "maze_std3_19px_10k")
+    _copy_split(mnist_root, "train", train_root / "mnist")
+    _copy_split(sudoku_root, "train", train_root / "sudoku_easy")
+    _copy_split(maze_root, "test", eval_root / "maze_std3_19px_10k")
+    _copy_split(mnist_root, "test", eval_root / "mnist")
+    _copy_split(sudoku_root, "test_hard", eval_root / "sudoku_easy")
+
+    test_count = 10_000
+    mask_bank = build_mnist_mask_bank(
+        f"ml-datasets-0.2.1:{sha256_file(mnist_root / 'test/images.npy')}",
+        range(test_count),
+    )
+    write_mnist_mask_bank(eval_root / "mnist/drop30-mask-bank.json", mask_bank)
+
+    marker("HEARTBEAT", "CPU_IMPORT:build-c5")
+    training_identities = _maze_training_identities(maze_root)
+    c5_receipts = {}
+    for size in C5_SIZES:
+        arrays, c5_manifest = generate_c5_size(
+            size,
+            training_identities=training_identities,
+            examples=1000,
+        )
+        c5_root = eval_root / "c5" / f"{size}x{size}"
+        write_puzzle_split(
+            c5_root,
+            "test",
+            arrays["inputs"],
+            arrays["labels"],
+            height=size,
+            width=size,
+        )
+        atomic_write_json(c5_root / "generation-manifest.json", c5_manifest)
+        c5_receipts[str(size)] = c5_manifest
+
+    shutil.copytree(handoff / "checkpoints", imports_root / "checkpoints")
+    shutil.copytree(handoff / "configs", imports_root / "configs")
+    shutil.copy2(handoff / "IMPORTS.json", imports_root / "IMPORTS.json")
+    shutil.copy2(handoff / "RIGHTS.json", imports_root / "RIGHTS.json")
+    manifests = {
+        "train": _tree_manifest(train_root),
+        "eval": _tree_manifest(eval_root),
+        "imports": _tree_manifest(imports_root),
+    }
+    for name, value in manifests.items():
+        atomic_write_json(workspace / f"{name}-tree-manifest.json", value)
+    return {
+        "tree_manifests": manifests,
+        "mnist_mask_bank_sha256": mask_bank["bank_sha256"],
+        "maze_training_identity_count": len(training_identities),
+        "c5": c5_receipts,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--science-spec", type=Path, required=True)
+    parser.add_argument("--job-manifest", type=Path, required=True)
+    parser.add_argument("--handoff", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--sudoku-revision", required=True)
+    parser.add_argument("--verify-checkpoints", action="store_true")
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+    spec = verify_science_spec(args.science_spec)
+    manifest = load_job_manifest(args.job_manifest)
+    if manifest["job_class"] != "CPU_IMPORT":
+        raise SystemExit("CPU import entrypoint requires a CPU_IMPORT manifest")
+    imports = _verify_handoff(args.handoff, verify_checkpoints=args.verify_checkpoints)
+    if args.dry_run:
+        print(
+            json.dumps(
+                {
+                    "contract_verified": True,
+                    "verified_import_rows": len(imports),
+                    "outcomes": {},
+                }
+            )
+        )
+        return 0
+    if args.sudoku_revision != spec["data_rules"]["sudoku"]["revision"]:
+        raise SystemExit("Sudoku revision differs from the frozen science spec")
+    args.output_dir.mkdir(parents=True, exist_ok=False)
+    marker("CPU_READY", "CPU_IMPORT")
+    with (
+        heartbeat("CPU_IMPORT"),
+        tempfile.TemporaryDirectory(prefix="sheaf-import-") as temporary,
+    ):
+        workspace = Path(temporary)
+        build_receipt = _build_registered_inputs(
+            args.handoff,
+            workspace,
+            sudoku_revision=args.sudoku_revision,
+        )
+        archive_hashes = {}
+        for name in ("train", "eval", "imports"):
+            archive = args.output_dir / f"{name}-data.tar.gz"
+            archive_hashes[name] = create_deterministic_tar_gz(workspace / name, archive)
+            shutil.copy2(
+                workspace / f"{name}-tree-manifest.json",
+                args.output_dir / f"{name}-tree-manifest.json",
+            )
+    receipt = {
+        "format": 1,
+        "logical_id": manifest["logical_id"],
+        "attempt_id": manifest["attempt_id"],
+        "verified_import_rows": len(imports),
+        "sudoku_revision": args.sudoku_revision,
+        "archives": archive_hashes,
+        "build": build_receipt,
+        "outcomes": {},
+    }
+    atomic_write_json(args.output_dir / "import-receipt.json", receipt)
+    finalize_attempt(
+        args.output_dir,
+        logical_id=manifest["logical_id"],
+        attempt_id=manifest["attempt_id"],
+        expected_outputs=manifest["expected_outputs"],
+    )
+    verify_read_back(
+        args.output_dir,
+        logical_id=manifest["logical_id"],
+        attempt_id=manifest["attempt_id"],
+    )
+    marker("DONE", f"{manifest['logical_id']} {manifest['attempt_id']}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/launch_job.py b/scripts/launch_job.py
new file mode 100644
index 0000000000000000000000000000000000000000..bbbd8c5d17649e5b2afcb17ab03e1284e988f6bb
--- /dev/null
+++ b/scripts/launch_job.py
@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""Prepare, submit, reconcile, poll, or cancel one durable direct HF Job attempt."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.hf_provider import HFJobsProvider
+from repro_control.launcher import (
+    AmbiguousSubmission,
+    BudgetSnapshot,
+    DirectLauncher,
+    LaunchError,
+    LauncherState,
+)
+
+
+def _launcher(args) -> DirectLauncher:
+    provider = HFJobsProvider(namespace=args.namespace) if args.action != "prepare" else None
+    return DirectLauncher(
+        args.state,
+        provider=provider,
+        enable_submit=args.enable_submit,
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--state", type=Path, required=True)
+    parser.add_argument("--namespace", default="Mindcraft")
+    parser.add_argument(
+        "--enable-submit",
+        action="store_true",
+        help="Required for submit/cancel; omitted by default to keep the CLI non-mutating.",
+    )
+    sub = parser.add_subparsers(dest="action", required=True)
+    prepare = sub.add_parser("prepare")
+    prepare.add_argument("--request", type=Path, required=True)
+    prepare.add_argument("--budget-snapshot", type=Path, required=True)
+    prepare.add_argument("--guarded-critical-path-seconds", type=int, required=True)
+    submit = sub.add_parser("submit")
+    submit.add_argument("--attempt-id", required=True)
+    reconcile = sub.add_parser("reconcile")
+    reconcile.add_argument("--attempt-id", required=True)
+    poll = sub.add_parser("poll")
+    poll.add_argument("--attempt-id", required=True)
+    cancel = sub.add_parser("cancel")
+    cancel.add_argument("--attempt-id", required=True)
+    sub.add_parser("show")
+    args = parser.parse_args()
+    launcher = _launcher(args)
+    try:
+        if args.action == "prepare":
+            request = json.loads(args.request.read_text())
+            budget = BudgetSnapshot(**json.loads(args.budget_snapshot.read_text()))
+            row = launcher.prepare(
+                request,
+                budget=budget,
+                now=datetime.now(UTC),
+                guarded_critical_path_seconds=args.guarded_critical_path_seconds,
+            )
+        elif args.action == "submit":
+            if not args.enable_submit:
+                raise LaunchError("submit requires --enable-submit")
+            row = launcher.submit_prepared(args.attempt_id)
+        elif args.action == "reconcile":
+            row = launcher.reconcile_ambiguous(args.attempt_id)
+        elif args.action == "poll":
+            row = launcher.poll(args.attempt_id, now=datetime.now(UTC))
+        elif args.action == "cancel":
+            if not args.enable_submit:
+                raise LaunchError("cancel requires --enable-submit")
+            launcher.cancel(args.attempt_id)
+            row = next(
+                item
+                for item in LauncherState.load(args.state).attempts
+                if item["attempt_id"] == args.attempt_id
+            )
+        else:
+            print(
+                json.dumps(
+                    {
+                        "format": 1,
+                        "attempts": LauncherState.load(args.state).attempts,
+                    },
+                    sort_keys=True,
+                )
+            )
+            return 0
+    except AmbiguousSubmission as exc:
+        print(str(exc), file=sys.stderr)
+        return 3
+    except (LaunchError, ValueError, KeyError) as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+    print(json.dumps(row, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/reduce_results.py b/scripts/reduce_results.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1f6678f0060d3cbd132e246502d0d37544d76d9
--- /dev/null
+++ b/scripts/reduce_results.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Apply one exhaustive registered reducer to accepted complete numeric inputs."""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.reducers import (
+    reduce_c1,
+    reduce_c2,
+    reduce_c3,
+    reduce_c4_maze,
+    reduce_c4_sudoku,
+    reduce_c5,
+)
+from repro_control.hashing import atomic_write_json
+
+
+def plain(value):
+    if dataclasses.is_dataclass(value):
+        return {field.name: plain(getattr(value, field.name)) for field in dataclasses.fields(value)}
+    if isinstance(value, dict):
+        return {str(key): plain(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [plain(item) for item in value]
+    return value
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--claim", choices=("c1", "c2", "c3", "c4-sudoku", "c4-maze", "c5"), required=True)
+    parser.add_argument("--input", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    value = json.loads(args.input.read_text())
+    reducers = {
+        "c1": reduce_c1,
+        "c2": reduce_c2,
+        "c3": reduce_c3,
+        "c4-sudoku": reduce_c4_sudoku,
+        "c4-maze": reduce_c4_maze,
+        "c5": reduce_c5,
+    }
+    result = reducers[args.claim](**value)
+    atomic_write_json(args.output, plain(result))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/replace_scaffold_cells.py b/scripts/replace_scaffold_cells.py
new file mode 100644
index 0000000000000000000000000000000000000000..67fe8d12ff6a8c74ff4c9be68edbc31a054b4d29
--- /dev/null
+++ b/scripts/replace_scaffold_cells.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Replace the two official pinned scaffold cells in place."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.scaffold import replace_scaffold_file
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--scaffold-export",
+        type=Path,
+        required=True,
+        help="Official Executive-summary page.md or a synthetic JSON export",
+    )
+    parser.add_argument("--summary", type=Path, required=True)
+    parser.add_argument("--poster", type=Path, required=True)
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+    replace_scaffold_file(
+        args.scaffold_export,
+        summary_path=args.summary,
+        poster_path=args.poster,
+        output_path=args.output,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/scan_privacy.py b/scripts/scan_privacy.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b4d89045b3b1f49cd44ac88ed0c487bbf431ebf
--- /dev/null
+++ b/scripts/scan_privacy.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""Write a deterministic privacy receipt for explicitly selected local roots."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.privacy import scan_paths, write_receipt
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--checkout", type=Path, required=True)
+    parser.add_argument("--root", type=Path, action="append", required=True)
+    parser.add_argument("--intended-remote-map", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    mapping = json.loads(args.intended_remote_map.read_text())
+    receipt = scan_paths(args.root, relative_to=args.checkout, intended_remote_map=mapping)
+    write_receipt(args.output, receipt, require_clean=False)
+    print(json.dumps({"exit_code": receipt["exit_code"], "findings": len(receipt["findings"])}))
+    return receipt["exit_code"]
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/smoke_repro.py b/scripts/smoke_repro.py
new file mode 100644
index 0000000000000000000000000000000000000000..da9e91bfed57a87416e52da28924cc934297c0bf
--- /dev/null
+++ b/scripts/smoke_repro.py
@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Run a real, verdict-isolated admission workload and seal its receipt."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.artifacts import finalize_attempt, verify_read_back
+from repro_control.hashing import atomic_write_json
+from repro_control.heartbeat import heartbeat, marker
+from repro_control.runtime import assert_smoke_isolated, load_job_manifest, verify_science_spec
+from repro_control.smoke_runtime import (
+    fixture_hashes,
+    orchestrate_family,
+    run_c5_probe_child,
+    run_family_child,
+)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--science-spec", type=Path)
+    parser.add_argument("--job-manifest", type=Path)
+    parser.add_argument("--family", choices=("sudoku", "maze-c5", "mnist"))
+    parser.add_argument("--project-root", type=Path, default=Path(__file__).resolve().parents[1])
+    parser.add_argument("--handoff", type=Path)
+    parser.add_argument("--output-dir", type=Path)
+    parser.add_argument("--steps-warmup", type=int, default=5)
+    parser.add_argument("--steps-measured", type=int, default=20)
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--allow-cpu-preflight", action="store_true")
+    parser.add_argument("--internal-family-child", choices=("sudoku", "maze-c5", "mnist"))
+    parser.add_argument("--internal-c5-probe-child", action="store_true")
+    parser.add_argument("--size", type=int)
+    parser.add_argument("--batch-size", type=int)
+    parser.add_argument("--timing", action="store_true")
+    args = parser.parse_args()
+
+    if args.internal_family_child:
+        value = run_family_child(
+            args.project_root,
+            args.handoff,
+            args.internal_family_child,
+            warmup_steps=args.steps_warmup,
+            measured_steps=args.steps_measured,
+            allow_cpu=args.allow_cpu_preflight,
+        )
+        print(json.dumps(value))
+        return 0
+    if args.internal_c5_probe_child:
+        value = run_c5_probe_child(
+            args.handoff,
+            size=args.size,
+            batch_size=args.batch_size,
+            timing=args.timing,
+            allow_cpu=args.allow_cpu_preflight,
+        )
+        print(json.dumps(value))
+        return 0
+
+    if not all((args.science_spec, args.job_manifest, args.family, args.handoff)):
+        parser.error("top-level smoke requires spec, manifest, family, and handoff")
+    verify_science_spec(args.science_spec)
+    manifest = load_job_manifest(args.job_manifest)
+    assert_smoke_isolated(manifest)
+    if (args.steps_warmup, args.steps_measured) != (5, 20):
+        raise SystemExit("registered smoke requires 5 warm-up and 20 measured steps")
+    if args.dry_run:
+        print(
+            json.dumps(
+                {
+                    "contract_verified": True,
+                    "family": args.family,
+                    "verdict_metrics_emitted": False,
+                    "outcomes": {},
+                }
+            )
+        )
+        return 0
+    if args.output_dir is None:
+        raise SystemExit("--output-dir is required for execution")
+    args.output_dir.mkdir(parents=True, exist_ok=False)
+    marker("CPU_PREFLIGHT_READY" if args.allow_cpu_preflight else "GPU_READY", args.family)
+    with heartbeat(f"GPU_SMOKE:{args.family}"):
+        result = orchestrate_family(
+            Path(__file__).resolve(),
+            args.project_root,
+            args.handoff,
+            args.family,
+            warmup_steps=args.steps_warmup,
+            measured_steps=args.steps_measured,
+            allow_cpu=args.allow_cpu_preflight,
+        )
+    receipt = {
+        "format": 1,
+        "logical_id": manifest["logical_id"],
+        "attempt_id": manifest["attempt_id"],
+        "family": args.family,
+        "fixture_hashes": fixture_hashes(args.handoff),
+        "warmup_steps": 5,
+        "measured_steps": 20,
+        "result": result,
+        "verdict_metrics_emitted": False,
+        "outcomes": {},
+    }
+    atomic_write_json(args.output_dir / "smoke-receipt.json", receipt)
+    finalize_attempt(
+        args.output_dir,
+        logical_id=manifest["logical_id"],
+        attempt_id=manifest["attempt_id"],
+        expected_outputs=manifest["expected_outputs"],
+    )
+    verify_read_back(
+        args.output_dir,
+        logical_id=manifest["logical_id"],
+        attempt_id=manifest["attempt_id"],
+    )
+    marker("DONE", f"{manifest['logical_id']} {manifest['attempt_id']}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/train.py b/scripts/train.py
new file mode 100644
index 0000000000000000000000000000000000000000..15663e12fb6a8ba46aef667cdf32f66722198d7a
--- /dev/null
+++ b/scripts/train.py
@@ -0,0 +1,261 @@
+"""Hydra training entrypoint for Sheaf-ADMM (and the MPNN baseline).
+
+One entrypoint for every task (maze / mnist / sudoku) and both model families
+(``model_type=sheaf|mpnn``); the task and HPs come entirely from config.
+
+    python scripts/train.py +experiment=maze_sheaf
+    python scripts/train.py +experiment=sudoku_sheaf training.seed=123
+    python scripts/train.py +experiment=mnist_sheaf
+
+Runs do not log by default. Set ``wandb.mode=online`` to enable Weights & Biases.
+Importing ``sheaf_admm`` pins ``float32`` matmul precision to ``highest`` (the
+paper setting) before any compilation.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+import hydra
+import jax
+import numpy as np
+import wandb
+from hydra.core.hydra_config import HydraConfig
+from omegaconf import DictConfig, OmegaConf
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT / "src") not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT / "src"))
+
+import sheaf_admm as _sheaf_admm  # noqa: F401,E402  (sets matmul precision on import)
+from repro_control.checkpoints import save_checkpoint_atomic  # noqa: E402
+from repro_control.configs import (  # noqa: E402
+    config_sha256,
+    load_json_config,
+    verify_before_optimizer,
+)
+from repro_control.hashing import atomic_write_json  # noqa: E402
+from repro_control.interventions import assert_common_bit_identical  # noqa: E402
+from sheaf_admm.data import ImageDataset, PuzzleDataset  # noqa: E402
+from sheaf_admm.models import model_config_from_dict  # noqa: E402
+from sheaf_admm.training import (  # noqa: E402
+    build_model,
+    create_train_state,
+    evaluate,
+    make_task,
+    make_train_step,
+    sample_k,
+)
+
+
+def _puzzle_batch(batch):
+    out = {"inputs": np.asarray(batch["inputs"]), "labels": np.asarray(batch["labels"])}
+    for key in ("height", "width"):
+        if key in batch:
+            out[key] = batch[key]
+    return out
+
+
+def _train_batches(cfg: DictConfig, epoch: int):
+    """Yield ``{inputs/images, labels}`` batches for one training epoch."""
+    d = cfg.data
+    if d.loader == "puzzle":
+        ds = PuzzleDataset(d.dir, d.train_split)
+        for _set, batch in ds.iter_train_batches(
+            cfg.training.batch_size, seed=cfg.training.seed + epoch
+        ):
+            yield _puzzle_batch(batch)
+    else:  # image
+        ds = ImageDataset(d.dir, d.train_split)
+        for batch in ds.iter_batches(
+            cfg.training.batch_size, shuffle=True, seed=cfg.training.seed + epoch
+        ):
+            yield {"images": np.asarray(batch["images"]), "labels": np.asarray(batch["labels"])}
+
+
+def _val_batches(cfg: DictConfig, split: str):
+    d = cfg.data
+    if d.loader == "puzzle":
+        ds = PuzzleDataset(d.dir, split)
+        for _set, batch in ds.iter_test_batches(cfg.training.batch_size):
+            yield _puzzle_batch(batch)
+    else:
+        ds = ImageDataset(d.dir, split)
+        for batch in ds.iter_batches(cfg.training.batch_size, shuffle=False):
+            yield {"images": np.asarray(batch["images"]), "labels": np.asarray(batch["labels"])}
+
+
+@hydra.main(config_path="../configs", config_name="config", version_base=None)
+def main(cfg: DictConfig) -> None:
+    sys.stdout.reconfigure(line_buffering=True)  # flush per line so sbatch log-tailing works live
+    expected_path = os.environ.get("REPRO_EXPECTED_CONFIG_PATH", "")
+    expected_sha256 = os.environ.get("REPRO_EXPECTED_CONFIG_SHA256", "")
+    if bool(expected_path) != bool(expected_sha256):
+        raise RuntimeError("both registered config environment variables are required together")
+    if expected_path:
+        resolved = OmegaConf.to_container(cfg, resolve=True)
+        expected = load_json_config(Path(expected_path))
+        verify_before_optimizer(resolved, expected, expected_sha256=expected_sha256)
+        if config_sha256(expected) != expected_sha256:
+            raise RuntimeError("registered config file hash mismatch")
+        print(f"CONFIG_VERIFIED {expected_sha256}", flush=True)
+    print(OmegaConf.to_yaml(cfg))
+    t = cfg.training
+    run = wandb.init(
+        project=cfg.wandb.project,
+        entity=cfg.wandb.entity,
+        name=cfg.wandb.name,
+        group=cfg.wandb.group,
+        tags=list(cfg.wandb.tags),
+        mode=cfg.wandb.mode,
+        config=OmegaConf.to_container(cfg, resolve=True),
+    )
+
+    task = make_task(cfg.task, **OmegaConf.to_container(cfg.task_cfg, resolve=True))
+    model_cfg = model_config_from_dict(OmegaConf.to_container(cfg.model, resolve=True))
+    model = build_model(model_cfg, cfg.model_type)
+    graph_readout = model_cfg.mpnn_graph_readout
+
+    sample_fwd, _, _ = task.prepare(next(_train_batches(cfg, 0)))
+    state = create_train_state(
+        model,
+        sample_fwd,
+        model_type=cfg.model_type,
+        lr=t.lr,
+        weight_decay=t.weight_decay,
+        warmup_steps=t.warmup_steps,
+        grad_clip=t.grad_clip,
+        ema_decay=t.ema_decay,
+        k_init=t.K_train,
+        loss_window=t.loss_window,
+        seed=cfg.training.seed,
+    )
+    if cfg.model_type == "sheaf" and bool(cfg.model.get("rm_constant", False)):
+        control_model_config = OmegaConf.to_container(cfg.model, resolve=True)
+        control_model_config["rm_init"] = "soft_slice"
+        control_model_config["rm_constant"] = False
+        control_model = build_model(model_config_from_dict(control_model_config), "sheaf")
+        control_state = create_train_state(
+            control_model,
+            sample_fwd,
+            model_type="sheaf",
+            lr=t.lr,
+            weight_decay=t.weight_decay,
+            warmup_steps=t.warmup_steps,
+            grad_clip=t.grad_clip,
+            ema_decay=t.ema_decay,
+            k_init=t.K_train,
+            loss_window=t.loss_window,
+            seed=cfg.training.seed,
+        )
+        counters = {"step": 0, "training_seed": int(cfg.training.seed)}
+        assert_common_bit_identical(
+            control_state.params,
+            state.params,
+            control_state.opt_state,
+            state.opt_state,
+            counters,
+            counters,
+        )
+        parity_path = Path(HydraConfig.get().runtime.output_dir) / "identity-parity.json"
+        atomic_write_json(
+            parity_path,
+            {
+                "format": 1,
+                "common_parameter_leaves_bit_identical": True,
+                "common_optimizer_leaves_bit_identical": True,
+                "counters_bit_identical": True,
+                "identity_parameter_tree_has_restriction_map": False,
+                "checked_before_first_optimizer_step": True,
+                "outcomes": {},
+            },
+        )
+        print("IDENTITY_COMMON_PARITY_VERIFIED", flush=True)
+    run.summary["params"] = sum(x.size for x in jax.tree_util.tree_leaves(state.params))
+    print(f"[init] model_type={cfg.model_type} params={run.summary['params']:,}")
+
+    train_step = make_train_step(task, cfg.model_type, graph_readout)
+    rng = jax.random.PRNGKey(cfg.training.seed)
+    rng_np = np.random.default_rng(cfg.training.seed)
+    history: list[dict] = []
+    best: dict[str, float] = {}
+    step = 0
+
+    for epoch in range(t.epochs):
+        for batch in _train_batches(cfg, epoch):
+            fwd, targets, _ = task.prepare(batch)
+            rng, sub = jax.random.split(rng)
+            k = (
+                sample_k(rng_np, t.train_iters_dist, t.train_iters_min, t.K_train)
+                if cfg.model_type == "sheaf"
+                else t.mpnn_train_rounds
+            )
+            state, loss = train_step(state, fwd, targets, sub, n_iter=k, loss_window=t.loss_window)
+            step += 1
+            loss = float(loss)
+            run.log({"train/loss": loss, "train/k": k, "epoch": epoch}, step=step)
+            if t.exit_on_nan and not np.isfinite(loss):
+                print(f"[epoch {epoch}] non-finite loss — stopping (exit_on_nan).")
+                run.finish(exit_code=1)
+                return
+
+        if epoch % t.val_interval == 0 or epoch == t.epochs - 1:
+            k_eval = t.K_eval if cfg.model_type == "sheaf" else t.mpnn_eval_rounds
+            row = {"epoch": epoch, "loss": loss}
+            for split in cfg.data.val_splits:
+                m = evaluate(
+                    state,
+                    task,
+                    _val_batches(cfg, split),
+                    model_type=cfg.model_type,
+                    graph_readout=graph_readout,
+                    k_eval=k_eval,
+                )
+                row[split] = m
+                run.log({f"val/{split}/{kk}": vv for kk, vv in m.items()}, step=step)
+                for kk, vv in m.items():  # track best-so-far in the run summary
+                    key = f"best/{split}/{kk}"
+                    best[key] = max(best.get(key, vv), vv)
+                print(
+                    f"[epoch {epoch}] loss={loss:.4f}  {split}: "
+                    + "  ".join(f"{kk}={vv * 100:.2f}%" for kk, vv in m.items())
+                )
+            history.append(row)
+            run.summary.update(best)
+        out = Path(HydraConfig.get().runtime.output_dir)
+        save_checkpoint_atomic(
+            out / "checkpoint.partial.pkl",
+            {
+                "params": jax.device_get(state.params),
+                "ema_params": jax.device_get(state.ema_params),
+                "optimizer_state": jax.device_get(state.opt_state),
+                "config": OmegaConf.to_container(cfg, resolve=True),
+                "next_epoch": epoch + 1,
+                "step": step,
+                "jax_rng": np.asarray(jax.device_get(rng)),
+                "numpy_rng_state": rng_np.bit_generator.state,
+            },
+        )
+        atomic_write_json(out / "history.partial.json", history)
+
+    out = Path(HydraConfig.get().runtime.output_dir)
+    save_checkpoint_atomic(
+        out / "checkpoint.pkl",
+        {
+            "params": jax.device_get(state.params),
+            "ema_params": jax.device_get(state.ema_params),
+            "optimizer_state": jax.device_get(state.opt_state),
+            "config": OmegaConf.to_container(cfg, resolve=True),
+            "seed": int(cfg.training.seed),
+            "final_epoch": int(t.epochs) - 1,
+        },
+    )
+    atomic_write_json(out / "history.json", history)
+    print(f"[done] saved checkpoint + history to {out}")
+    run.finish()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/train_repro.py b/scripts/train_repro.py
new file mode 100644
index 0000000000000000000000000000000000000000..696bb0275da4857b098ee146378695bae8f2da0f
--- /dev/null
+++ b/scripts/train_repro.py
@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""Scientific training contract gate for one registered isolated seed."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import pickle
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from repro_control.archives import safe_extract_tar_gz
+from repro_control.artifacts import finalize_attempt, verify_read_back
+from repro_control.configs import (
+    config_sha256,
+    load_json_config,
+    registered_config_for,
+    verify_before_optimizer,
+)
+from repro_control.hashing import atomic_write_json, sha256_file
+from repro_control.heartbeat import heartbeat, marker
+from repro_control.interventions import contains_restriction_map
+from repro_control.runtime import (
+    configure_scientific_runtime,
+    load_job_manifest,
+    require_control_freeze,
+    require_jax_platform,
+    verify_science_spec,
+)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--science-spec", type=Path, required=True)
+    parser.add_argument("--job-manifest", type=Path, required=True)
+    parser.add_argument("--control-dir", type=Path, required=True)
+    parser.add_argument("--freeze-sha256", required=True)
+    parser.add_argument("--data-dir", type=Path)
+    parser.add_argument("--train-archive", type=Path)
+    parser.add_argument("--output-dir", type=Path)
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+    spec = verify_science_spec(args.science_spec)
+    manifest = load_job_manifest(args.job_manifest, freeze_sha256=args.freeze_sha256)
+    if manifest["job_class"] != "SCIENTIFIC_TRAIN":
+        raise SystemExit("training entrypoint requires SCIENTIFIC_TRAIN")
+    if manifest["logical_id"] not in spec["run_identities"]:
+        raise SystemExit("unregistered training logical identity")
+    require_control_freeze(args.control_dir, args.freeze_sha256, manifest["science_spec_sha256"])
+    configure_scientific_runtime()
+    if args.dry_run:
+        print(
+            json.dumps(
+                {
+                    "contract_verified": True,
+                    "logical_id": manifest["logical_id"],
+                    "outcomes": {},
+                }
+            )
+        )
+        return 0
+    if args.data_dir is None or args.output_dir is None:
+        raise SystemExit("--data-dir and --output-dir are required for execution")
+    if args.train_archive:
+        safe_extract_tar_gz(args.train_archive, args.data_dir)
+    require_jax_platform("gpu")
+    marker("GPU_READY", manifest["logical_id"])
+    logical_id = manifest["logical_id"]
+    seed = manifest["seed"]
+    expected_path = args.control_dir / "registered-configs" / f"{logical_id}.json"
+    expected = load_json_config(expected_path)
+    expected_sha256 = config_sha256(expected)
+    if expected_sha256 != manifest["hashes"]["config"]:
+        raise SystemExit("registered config hash differs from the Job manifest")
+    independently_composed = registered_config_for(
+        Path(__file__).resolve().parents[1],
+        logical_id,
+        data_root=str(args.data_dir),
+    )
+    verify_before_optimizer(
+        independently_composed,
+        expected,
+        expected_sha256=expected_sha256,
+    )
+    args.output_dir.mkdir(parents=True, exist_ok=False)
+    with heartbeat(f"SCIENTIFIC_TRAIN:{logical_id}"):
+        if logical_id.startswith("C3-MNIST-CNN-"):
+            from repro_control.cnn_training import train_fixed_cnn
+
+            train_fixed_cnn(
+                Path(expected["data"]["dir"]),
+                args.output_dir,
+                seed=seed,
+                registered_config=expected,
+                registered_config_sha256=expected_sha256,
+            )
+        else:
+            root = Path(__file__).resolve().parents[1]
+            if logical_id.startswith("C1-SUD-MPNN225-"):
+                experiment = "sudoku_mpnn"
+                overrides = [
+                    "model.d_v=225",
+                    "training.lr=1.7e-3",
+                    "training.epochs=10",
+                ]
+            elif logical_id.startswith("C2-MAZE-MPNN84-"):
+                experiment = "maze_mpnn"
+                overrides = []
+            elif logical_id.startswith("C4-SUD-IDENTITY-"):
+                experiment = "sudoku_sheaf"
+                overrides = ["model.rm_init=identity", "+model.rm_constant=true"]
+            elif logical_id.startswith("C4-MAZE-QUADRATIC-"):
+                experiment = "maze_sheaf"
+                overrides = ["model.objective_mode=quadratic"]
+            else:
+                raise SystemExit("no registered training backend")
+            command = [
+                sys.executable,
+                str(root / "scripts" / "train.py"),
+                f"+experiment={experiment}",
+                f"training.seed={seed}",
+                f"data.dir={expected['data']['dir']}",
+                "data.val_splits=[]",
+                "wandb.mode=disabled",
+                f"hydra.run.dir={args.output_dir}",
+                *overrides,
+            ]
+            env = os.environ.copy()
+            env.update(
+                REPRO_EXPECTED_CONFIG_PATH=str(expected_path),
+                REPRO_EXPECTED_CONFIG_SHA256=expected_sha256,
+            )
+            subprocess.run(command, check=True, env=env)
+
+    checkpoint_path = args.output_dir / "checkpoint.pkl"
+    with checkpoint_path.open("rb") as handle:
+        checkpoint = pickle.load(handle)
+        if handle.read(1):
+            raise SystemExit("checkpoint contains trailing bytes")
+    if checkpoint.get("ema_params") is None:
+        raise SystemExit("training checkpoint lacks EMA parameters")
+    import jax
+
+    parameter_count = sum(
+        int(leaf.size) for leaf in jax.tree_util.tree_leaves(checkpoint["params"])
+    )
+    identity_parity = None
+    if logical_id.startswith("C4-SUD-IDENTITY-"):
+        parity_path = args.output_dir / "identity-parity.json"
+        if not parity_path.is_file():
+            raise SystemExit("identity training lacks the pre-step parity receipt")
+        identity_parity = json.loads(parity_path.read_text())
+        if not all(
+            identity_parity.get(name) is True
+            for name in (
+                "common_parameter_leaves_bit_identical",
+                "common_optimizer_leaves_bit_identical",
+                "counters_bit_identical",
+                "checked_before_first_optimizer_step",
+            )
+        ):
+            raise SystemExit("identity pre-step parity receipt is not affirmative")
+        if contains_restriction_map(checkpoint["params"]):
+            raise SystemExit("identity checkpoint unexpectedly contains restriction-map parameters")
+    receipt = {
+        "format": 1,
+        "logical_id": logical_id,
+        "attempt_id": manifest["attempt_id"],
+        "seed": seed,
+        "registered_config_sha256": expected_sha256,
+        "checkpoint_sha256": sha256_file(checkpoint_path),
+        "history_sha256": sha256_file(args.output_dir / "history.json"),
+        "parameter_count": parameter_count,
+        "ema": True,
+        "fixed_final_epoch": int(expected["training"]["epochs"]) - 1,
+        "identity_common_parity": identity_parity,
+        "outcomes": {},
+    }
+    atomic_write_json(args.output_dir / "training-receipt.json", receipt)
+    finalize_attempt(
+        args.output_dir,
+        logical_id=logical_id,
+        attempt_id=manifest["attempt_id"],
+        expected_outputs=manifest["expected_outputs"],
+    )
+    verify_read_back(
+        args.output_dir,
+        logical_id=logical_id,
+        attempt_id=manifest["attempt_id"],
+    )
+    marker("DONE", f"{logical_id} {manifest['attempt_id']}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/visualize.py b/scripts/visualize.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ecc8695a873a89b52895d2fe85714df73d2ad18
--- /dev/null
+++ b/scripts/visualize.py
@@ -0,0 +1,153 @@
+"""Emit the paper's analysis artifacts from a trained Sheaf-ADMM checkpoint.
+
+Loads a ``checkpoint.pkl`` written by ``scripts/train.py`` (a dict with
+``params`` / ``ema_params`` / ``config``), rebuilds the model + task from the
+embedded config, pulls one validation batch, and writes the three artifacts:
+
+* ``prediction_evolution.pdf`` — global prediction vs ADMM count ``k``;
+* ``coordination_dynamics.pdf`` — primal/dual residual heatmaps + curves;
+* ``xz_trajectories.pdf`` — per-agent x-vs-z 2-D trajectories.
+
+    python -m scripts.visualize --checkpoint outputs/.../checkpoint.pkl --out-dir /tmp/viz
+
+The ``--task`` / ``--data-dir`` flags override what the checkpoint config says
+(useful for visualizing on an OOD split). Evaluation uses the EMA parameters by
+default (``--params ema``), matching how the trainer reports metrics.
+Only Sheaf-ADMM checkpoints are supported; MPNN baselines do not expose an ADMM
+trajectory.
+"""
+
+from __future__ import annotations
+
+import argparse
+import pickle
+import sys
+from pathlib import Path
+
+import numpy as np
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT / "src") not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT / "src"))
+
+import sheaf_admm as _sheaf_admm  # noqa: F401,E402  (sets matmul precision on import)
+from sheaf_admm.data import ImageDataset, PuzzleDataset  # noqa: E402
+from sheaf_admm.models import model_config_from_dict  # noqa: E402
+from sheaf_admm.training import build_model, make_task  # noqa: E402
+from sheaf_admm.viz import (  # noqa: E402
+    plot_coordination_dynamics,
+    plot_prediction_evolution,
+    plot_xz_trajectories,
+    run_trajectory,
+)
+
+# Default per-task ADMM counts for the prediction-evolution panels.
+DEFAULT_KS = {"maze": (1, 3, 5, 10, 30), "sudoku": (1, 3, 5, 10, 20), "mnist": (1, 3, 5, 10, 30)}
+
+
+def _first_batch(cfg: dict, task_name: str, data_dir: str, split: str):
+    loader = cfg["data"].get("loader", "puzzle" if task_name in ("maze", "sudoku") else "image")
+    if loader == "puzzle":
+        ds = PuzzleDataset(data_dir, split)
+        for _set, b in ds.iter_test_batches(batch_size=8):
+            batch = {"inputs": np.asarray(b["inputs"]), "labels": np.asarray(b["labels"])}
+            for key in ("height", "width"):
+                if key in b:
+                    batch[key] = b[key]
+            return batch
+    ds = ImageDataset(data_dir, split)
+    for b in ds.iter_batches(batch_size=8, shuffle=False):
+        return {"images": np.asarray(b["images"]), "labels": np.asarray(b["labels"])}
+    raise RuntimeError("no batch available from the dataset")
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--checkpoint", required=True, help="path to checkpoint.pkl")
+    p.add_argument("--out-dir", required=True, help="directory for the artifact files")
+    p.add_argument("--task", default=None, help="override task (maze|sudoku|mnist)")
+    p.add_argument("--data-dir", default=None, help="override dataset directory")
+    p.add_argument("--split", default=None, help="dataset split (default: first val split)")
+    p.add_argument("--params", choices=("ema", "raw"), default="ema", help="which weights to use")
+    p.add_argument(
+        "--num-iters", type=int, default=30, help="ADMM steps for the trajectory artifacts"
+    )
+    p.add_argument("--batch-index", type=int, default=0, help="example index within the batch")
+    p.add_argument(
+        "--ks", type=int, nargs="+", default=None, help="ADMM counts for prediction evolution"
+    )
+    args = p.parse_args()
+
+    with open(args.checkpoint, "rb") as f:
+        ckpt = pickle.load(f)
+    cfg = ckpt["config"]
+    if cfg.get("model_type") != "sheaf":
+        raise ValueError(
+            "scripts.visualize supports Sheaf-ADMM checkpoints only "
+            f"(got model_type={cfg.get('model_type')!r})."
+        )
+    params = ckpt.get("ema_params") if args.params == "ema" else ckpt["params"]
+    if params is None:
+        params = ckpt["params"]
+
+    task_name = args.task or cfg["task"]
+    data_dir = args.data_dir or cfg["data"]["dir"]
+    split = args.split or cfg["data"]["val_splits"][0]
+    ks = tuple(args.ks) if args.ks else DEFAULT_KS[task_name]
+
+    task = make_task(task_name, **cfg.get("task_cfg", {}))
+    model_cfg = model_config_from_dict(cfg["model"])
+    model = build_model(model_cfg, cfg["model_type"])
+
+    batch = _first_batch(cfg, task_name, data_dir, split)
+    fwd, targets, aux = task.prepare(batch)
+
+    out_dir = Path(args.out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    written = []
+    written.append(
+        plot_prediction_evolution(
+            model,
+            params,
+            task,
+            fwd,
+            targets,
+            aux,
+            ks,
+            str(out_dir / "prediction_evolution.pdf"),
+            batch_index=args.batch_index,
+            title=f"{task_name}: prediction vs k",
+        )
+    )
+
+    centers = aux.get("centers")
+    traj = run_trajectory(
+        model,
+        params,
+        fwd,
+        num_iters=args.num_iters,
+        batch_index=args.batch_index,
+        centers=centers,
+    )
+    written.append(
+        plot_coordination_dynamics(
+            traj,
+            str(out_dir / "coordination_dynamics.pdf"),
+            title=f"{task_name}: coordination dynamics (rho={traj.rho:.3g})",
+        )
+    )
+    written.append(
+        plot_xz_trajectories(
+            traj,
+            str(out_dir / "xz_trajectories.pdf"),
+            title=f"{task_name}: x vs z trajectories",
+        )
+    )
+
+    for path in written:
+        print(f"[viz] wrote {path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/repro_control/__init__.py b/src/repro_control/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dcc81ba8f664f45e3ff5cec81d0c7bbf061573c5
--- /dev/null
+++ b/src/repro_control/__init__.py
@@ -0,0 +1,5 @@
+"""Fail-closed control plane for the registered local reproduction."""
+
+from .constants import SCIENCE_SPEC_SHA256
+
+__all__ = ["SCIENCE_SPEC_SHA256"]
diff --git a/src/repro_control/aggregation.py b/src/repro_control/aggregation.py
new file mode 100644
index 0000000000000000000000000000000000000000..56e349665462c48a45a2cd888d996b9aa3f34e53
--- /dev/null
+++ b/src/repro_control/aggregation.py
@@ -0,0 +1,69 @@
+"""Accepted-attempt registry and complete-only aggregation."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .artifacts import verify_read_back
+from .hashing import atomic_write_json, sha256_file
+
+
+class AggregationError(ValueError):
+    pass
+
+
+def accept_attempt(
+    registry_path: Path,
+    *,
+    logical_id: str,
+    attempt_id: str,
+    prefix: Path,
+) -> dict[str, Any]:
+    registry = (
+        json.loads(registry_path.read_text())
+        if registry_path.exists()
+        else {"format": 1, "accepted_attempts": []}
+    )
+    if set(registry) != {"format", "accepted_attempts"} or registry["format"] != 1:
+        raise AggregationError("invalid accepted-attempt registry")
+    existing = [
+        row for row in registry["accepted_attempts"] if row["logical_id"] == logical_id
+    ]
+    if existing:
+        raise AggregationError(f"logical identity already accepted: {logical_id}")
+    done = verify_read_back(prefix, logical_id=logical_id, attempt_id=attempt_id)
+    row = {
+        "logical_id": logical_id,
+        "attempt_id": attempt_id,
+        "prefix": prefix.as_posix(),
+        "done_sha256": sha256_file(prefix / "DONE.json"),
+        "object_root_sha256": done["object_root_sha256"],
+    }
+    registry["accepted_attempts"].append(row)
+    registry["accepted_attempts"].sort(key=lambda item: item["logical_id"])
+    atomic_write_json(registry_path, registry)
+    return row
+
+
+def load_complete_units(registry_path: Path, required_logical_ids: set[str]) -> list[dict[str, Any]]:
+    registry = json.loads(registry_path.read_text())
+    rows = registry["accepted_attempts"]
+    identities = [row["logical_id"] for row in rows]
+    if len(identities) != len(set(identities)):
+        raise AggregationError("duplicate accepted logical identities")
+    missing = required_logical_ids - set(identities)
+    extra = set(identities) - required_logical_ids
+    if missing or extra:
+        raise AggregationError(f"accepted identity mismatch: missing={sorted(missing)} extra={sorted(extra)}")
+    for row in rows:
+        prefix = Path(row["prefix"])
+        done = verify_read_back(
+            prefix, logical_id=row["logical_id"], attempt_id=row["attempt_id"]
+        )
+        if sha256_file(prefix / "DONE.json") != row["done_sha256"]:
+            raise AggregationError("accepted DONE receipt changed")
+        if done["object_root_sha256"] != row["object_root_sha256"]:
+            raise AggregationError("accepted object root changed")
+    return rows
diff --git a/src/repro_control/archives.py b/src/repro_control/archives.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd1712676bb7e21f1f8c5dd921af0cbfb89954c4
--- /dev/null
+++ b/src/repro_control/archives.py
@@ -0,0 +1,75 @@
+"""Deterministic input archives and traversal-safe extraction."""
+
+from __future__ import annotations
+
+import gzip
+import shutil
+import tarfile
+from pathlib import Path, PurePosixPath
+
+from .hashing import sha256_file
+
+
+class ArchiveError(ValueError):
+    pass
+
+
+def create_deterministic_tar_gz(source: Path, destination: Path) -> str:
+    if not source.is_dir():
+        raise ArchiveError(f"archive source is not a directory: {source}")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with (
+        destination.open("wb") as raw,
+        gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0) as compressed,
+        tarfile.open(fileobj=compressed, mode="w", format=tarfile.PAX_FORMAT) as archive,
+    ):
+        for path in sorted(source.rglob("*")):
+            relative = path.relative_to(source)
+            info = archive.gettarinfo(str(path), arcname=relative.as_posix())
+            info.uid = 0
+            info.gid = 0
+            info.uname = ""
+            info.gname = ""
+            info.mtime = 0
+            info.mode = 0o755 if path.is_dir() else 0o644
+            if path.is_file():
+                with path.open("rb") as handle:
+                    archive.addfile(info, handle)
+            elif path.is_dir():
+                archive.addfile(info)
+            else:
+                raise ArchiveError(f"unsupported archive entry: {path}")
+    return sha256_file(destination)
+
+
+def safe_extract_tar_gz(archive_path: Path, destination: Path) -> None:
+    if destination.exists() and any(destination.iterdir()):
+        raise ArchiveError(f"extraction destination is not empty: {destination}")
+    destination.mkdir(parents=True, exist_ok=True)
+    with tarfile.open(archive_path, mode="r:gz") as archive:
+        members = archive.getmembers()
+        names = set()
+        for member in members:
+            relative = PurePosixPath(member.name)
+            if relative.is_absolute() or ".." in relative.parts or not relative.parts:
+                raise ArchiveError(f"unsafe archive member: {member.name!r}")
+            if member.name in names:
+                raise ArchiveError(f"duplicate archive member: {member.name!r}")
+            names.add(member.name)
+            if member.issym() or member.islnk() or member.isdev():
+                raise ArchiveError(f"links/devices are forbidden in input archives: {member.name}")
+        archive.extractall(destination, members=members, filter="data")
+
+
+def copy_tree_selected(source: Path, destination: Path, names: tuple[str, ...]) -> None:
+    destination.mkdir(parents=True, exist_ok=True)
+    for name in names:
+        src = source / name
+        dst = destination / name
+        if not src.exists():
+            raise ArchiveError(f"selected source does not exist: {src}")
+        if src.is_dir():
+            shutil.copytree(src, dst)
+        else:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dst)
diff --git a/src/repro_control/artifacts.py b/src/repro_control/artifacts.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3176f7e4dbc9d3714c59564cae9dbd8652668ec
--- /dev/null
+++ b/src/repro_control/artifacts.py
@@ -0,0 +1,85 @@
+"""Incremental object manifests, DONE-last completion, and independent read-back."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .hashing import atomic_write_json, canonical_root, file_entry, sha256_file
+
+OBJECT_MANIFEST = "OBJECT-MANIFEST.json"
+DONE_MARKER = "DONE.json"
+
+
+class ArtifactError(ValueError):
+    pass
+
+
+def build_object_manifest(prefix: Path, expected_outputs: list[str]) -> dict[str, Any]:
+    forbidden = {OBJECT_MANIFEST, DONE_MARKER}
+    outputs = [name for name in expected_outputs if name not in forbidden]
+    entries = []
+    for name in outputs:
+        path = prefix / name
+        if not path.is_file():
+            raise ArtifactError(f"missing expected output {name}")
+        entries.append(file_entry(path, relative_to=prefix))
+    manifest = {"format": 1, "entries": entries, "root_sha256": canonical_root(entries)}
+    atomic_write_json(prefix / OBJECT_MANIFEST, manifest)
+    return manifest
+
+
+def finalize_attempt(
+    prefix: Path,
+    *,
+    logical_id: str,
+    attempt_id: str,
+    expected_outputs: list[str],
+) -> dict[str, Any]:
+    if (prefix / DONE_MARKER).exists():
+        raise ArtifactError("DONE.json already exists")
+    manifest = build_object_manifest(prefix, expected_outputs)
+    done = {
+        "format": 1,
+        "logical_id": logical_id,
+        "attempt_id": attempt_id,
+        "object_manifest_sha256": sha256_file(prefix / OBJECT_MANIFEST),
+        "object_root_sha256": manifest["root_sha256"],
+        "complete": True,
+        "outcomes": {},
+    }
+    atomic_write_json(prefix / DONE_MARKER, done)
+    return done
+
+
+def verify_read_back(
+    prefix: Path, *, logical_id: str | None = None, attempt_id: str | None = None
+) -> dict[str, Any]:
+    done_path = prefix / DONE_MARKER
+    manifest_path = prefix / OBJECT_MANIFEST
+    if not done_path.is_file() or not manifest_path.is_file():
+        raise ArtifactError("attempt lacks completion markers")
+    done = json.loads(done_path.read_text())
+    manifest = json.loads(manifest_path.read_text())
+    if done.get("complete") is not True or done.get("outcomes") != {}:
+        raise ArtifactError("invalid local pre-outcome DONE marker")
+    if logical_id is not None and done.get("logical_id") != logical_id:
+        raise ArtifactError("logical_id mismatch")
+    if attempt_id is not None and done.get("attempt_id") != attempt_id:
+        raise ArtifactError("attempt_id mismatch")
+    if done.get("object_manifest_sha256") != sha256_file(manifest_path):
+        raise ArtifactError("object manifest hash mismatch")
+    actual = []
+    for row in manifest.get("entries", []):
+        path = prefix / row["path"]
+        if not path.is_file():
+            raise ArtifactError(f"missing object {row['path']}")
+        entry = file_entry(path, relative_to=prefix)
+        if entry != row:
+            raise ArtifactError(f"read-back mismatch {row['path']}")
+        actual.append(entry)
+    root = canonical_root(actual)
+    if root != manifest.get("root_sha256") or root != done.get("object_root_sha256"):
+        raise ArtifactError("object root mismatch")
+    return done
diff --git a/src/repro_control/c5_runtime.py b/src/repro_control/c5_runtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..d265db73ee7cbf7eae2eae8594bda10b62c7a912
--- /dev/null
+++ b/src/repro_control/c5_runtime.py
@@ -0,0 +1,52 @@
+"""C5 GPU admission probing and deterministic padded-tail runtime checks."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+BATCH_CANDIDATES = (1, 2, 4, 8, 16, 32, 64, 128)
+
+
+class C5RuntimeError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class Probe:
+    batch_size: int
+    peak_bytes: int
+    post_compile_seconds: tuple[float, float, float]
+    weight_swap_compile_counts: tuple[int, int, int]
+
+
+def select_batch(probes: list[Probe], total_vram_bytes: int) -> Probe:
+    by_size = {probe.batch_size: probe for probe in probes}
+    if 1 not in by_size:
+        raise C5RuntimeError("batch-1 probe failure rejects the route")
+    valid = []
+    for size in BATCH_CANDIDATES:
+        probe = by_size.get(size)
+        if probe is None:
+            continue
+        if probe.peak_bytes <= 0 or probe.peak_bytes > 0.8 * total_vram_bytes:
+            continue
+        if len(probe.post_compile_seconds) != 3 or any(
+            value <= 0 for value in probe.post_compile_seconds
+        ):
+            raise C5RuntimeError("each probe needs three positive post-compile timings")
+        if probe.weight_swap_compile_counts != (1, 1, 1):
+            raise C5RuntimeError("all three weight swaps must reuse one compiled executable")
+        valid.append(probe)
+    if not valid:
+        raise C5RuntimeError("no batch size meets the 80% VRAM and parity contract")
+    return max(valid, key=lambda probe: probe.batch_size)
+
+
+def padded_tail(total_examples: int, batch_size: int) -> tuple[int, tuple[bool, ...]]:
+    if total_examples <= 0 or batch_size <= 0:
+        raise ValueError("total_examples and batch_size must be positive")
+    remainder = total_examples % batch_size
+    real = batch_size if remainder == 0 else remainder
+    return (total_examples + batch_size - 1) // batch_size, tuple(
+        index < real for index in range(batch_size)
+    )
diff --git a/src/repro_control/checkpoints.py b/src/repro_control/checkpoints.py
new file mode 100644
index 0000000000000000000000000000000000000000..1de8336a65b9712d45962530d723adf6fc77c0d8
--- /dev/null
+++ b/src/repro_control/checkpoints.py
@@ -0,0 +1,93 @@
+"""Neutral checkpoint hashing, structural validation, and atomic round trips."""
+
+from __future__ import annotations
+
+import json
+import os
+import pickle
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from .hashing import sha256_file
+
+
+class CheckpointError(ValueError):
+    pass
+
+
+def _tree_leaves(value: Any):
+    if isinstance(value, dict):
+        for key in sorted(value):
+            yield from _tree_leaves(value[key])
+    elif isinstance(value, (list, tuple)):
+        for item in value:
+            yield from _tree_leaves(item)
+    else:
+        yield value
+
+
+def parameter_count(tree: Any) -> int:
+    total = 0
+    for leaf in _tree_leaves(tree):
+        size = getattr(leaf, "size", None)
+        if size is None:
+            if isinstance(leaf, (int, float, bool, complex)):
+                size = 1
+            else:
+                raise CheckpointError(f"non-array parameter leaf {type(leaf).__name__}")
+        total += int(size)
+    return total
+
+
+def load_neutral_checkpoint(
+    checkpoint_path: Path,
+    config_path: Path,
+    import_row: dict[str, Any],
+) -> tuple[Any, dict[str, Any]]:
+    if checkpoint_path.stat().st_size != import_row["byte_size"]:
+        raise CheckpointError("checkpoint byte-size mismatch")
+    if sha256_file(checkpoint_path) != import_row["checkpoint_sha256"]:
+        raise CheckpointError("checkpoint hash mismatch")
+    if sha256_file(config_path) != import_row["sanitized_config_sha256"]:
+        raise CheckpointError("sanitized config hash mismatch")
+    config = json.loads(config_path.read_text())
+    with checkpoint_path.open("rb") as handle:
+        checkpoint = pickle.load(handle)
+        if handle.read(1):
+            raise CheckpointError("trailing checkpoint bytes")
+    if not isinstance(checkpoint, dict):
+        raise CheckpointError("checkpoint root must be a mapping")
+    params = checkpoint.get("params")
+    ema = checkpoint.get("ema_params")
+    if params is None or ema is None:
+        raise CheckpointError("checkpoint must contain params and EMA params")
+    if import_row["ema_status"]["present"] is not True:
+        raise CheckpointError("import row does not authorize EMA evaluation")
+    if parameter_count(params) != parameter_count(ema):
+        raise CheckpointError("parameter and EMA tree counts differ")
+    return checkpoint, config
+
+
+def save_checkpoint_atomic(path: Path, checkpoint: dict[str, Any]) -> str:
+    if "params" not in checkpoint or "ema_params" not in checkpoint:
+        raise CheckpointError("checkpoint must contain params and ema_params")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+    try:
+        with os.fdopen(descriptor, "wb") as handle:
+            pickle.dump(checkpoint, handle, protocol=5)
+            handle.flush()
+            os.fsync(handle.fileno())
+        with open(temporary, "rb") as handle:
+            reloaded = pickle.load(handle)
+        if parameter_count(reloaded["params"]) != parameter_count(checkpoint["params"]):
+            raise CheckpointError("checkpoint round-trip parameter mismatch")
+        os.replace(temporary, path)
+    except BaseException:
+        try:
+            os.unlink(temporary)
+        except FileNotFoundError:
+            pass
+        raise
+    return sha256_file(path)
diff --git a/src/repro_control/cnn.py b/src/repro_control/cnn.py
new file mode 100644
index 0000000000000000000000000000000000000000..2af80a169e411d5e2b3748cece71222375f0f985
--- /dev/null
+++ b/src/repro_control/cnn.py
@@ -0,0 +1,109 @@
+"""Exact fixed MNIST CNN registered for Claim 3."""
+
+from __future__ import annotations
+
+from typing import Any
+
+PARAMETER_COUNT = 65_642
+
+
+def _jax():
+    import jax
+    import jax.numpy as jnp
+
+    return jax, jnp
+
+
+def init_params(key) -> dict[str, dict[str, Any]]:
+    jax, jnp = _jax()
+
+    def layer(subkey, shape):
+        fan_in = shape[0] * shape[1] * shape[2] if len(shape) == 4 else shape[0]
+        fan_out = shape[0] * shape[1] * shape[3] if len(shape) == 4 else shape[1]
+        limit = jnp.sqrt(jnp.asarray(6.0 / (fan_in + fan_out), dtype=jnp.float32))
+        return jax.random.uniform(subkey, shape, jnp.float32, -limit, limit)
+
+    keys = jax.random.split(key, 5)
+    params = {
+        "conv1": {"kernel": layer(keys[0], (3, 3, 1, 32)), "bias": jnp.zeros((32,), jnp.float32)},
+        "conv2": {"kernel": layer(keys[1], (3, 3, 32, 32)), "bias": jnp.zeros((32,), jnp.float32)},
+        "conv3": {"kernel": layer(keys[2], (3, 3, 32, 64)), "bias": jnp.zeros((64,), jnp.float32)},
+        "conv4": {"kernel": layer(keys[3], (3, 3, 64, 64)), "bias": jnp.zeros((64,), jnp.float32)},
+        "dense": {"kernel": layer(keys[4], (64, 10)), "bias": jnp.zeros((10,), jnp.float32)},
+    }
+    if count_parameters(params) != PARAMETER_COUNT:
+        raise AssertionError("fixed CNN parameter count mismatch")
+    return params
+
+
+def forward(params, images, *, return_shapes: bool = False):
+    jax, jnp = _jax()
+    x = jnp.asarray(images, dtype=jnp.float32)
+    if x.ndim != 4 or x.shape[-1] != 1 or x.shape[1] not in (28, 60) or x.shape[2] != x.shape[1]:
+        raise ValueError("images must be float32 [B,28,28,1] or [B,60,60,1]")
+    shapes = [tuple(x.shape)]
+
+    def conv(value, layer):
+        value = jax.lax.conv_general_dilated(
+            value,
+            params[layer]["kernel"],
+            window_strides=(1, 1),
+            padding="SAME",
+            dimension_numbers=("NHWC", "HWIO", "NHWC"),
+        )
+        return jax.nn.relu(value + params[layer]["bias"])
+
+    x = conv(x, "conv1")
+    x = conv(x, "conv2")
+    shapes.append(tuple(x.shape))
+    x = jax.lax.reduce_window(
+        x,
+        -jnp.inf,
+        jax.lax.max,
+        window_dimensions=(1, 2, 2, 1),
+        window_strides=(1, 2, 2, 1),
+        padding="VALID",
+    )
+    shapes.append(tuple(x.shape))
+    x = conv(x, "conv3")
+    x = conv(x, "conv4")
+    x = jnp.mean(x, axis=(1, 2))
+    logits = x @ params["dense"]["kernel"] + params["dense"]["bias"]
+    return (logits, shapes) if return_shapes else logits
+
+
+def count_parameters(params) -> int:
+    jax, _ = _jax()
+    return sum(int(leaf.size) for leaf in jax.tree_util.tree_leaves(params))
+
+
+def kernel_weight_decay_mask(params):
+    jax, _ = _jax()
+    flat, structure = jax.tree_util.tree_flatten_with_path(params)
+    leaves = [bool(path and getattr(path[-1], "key", None) == "kernel") for path, _ in flat]
+    return jax.tree_util.tree_unflatten(structure, leaves)
+
+
+def padded_masked_batches(images, labels, *, batch_size: int = 128):
+    """Yield fixed-size batches and real-example masks for exact loss normalization."""
+    _, jnp = _jax()
+    images, labels = jnp.asarray(images), jnp.asarray(labels)
+    if len(images) != len(labels):
+        raise ValueError("images and labels length mismatch")
+    for start in range(0, len(images), batch_size):
+        stop = min(start + batch_size, len(images))
+        real = stop - start
+        pad = batch_size - real
+        yield (
+            jnp.pad(images[start:stop], ((0, pad), (0, 0), (0, 0), (0, 0))),
+            jnp.pad(labels[start:stop], ((0, pad),)),
+            jnp.arange(batch_size) < real,
+        )
+
+
+def masked_sparse_cross_entropy(logits, labels, mask):
+    jax, jnp = _jax()
+    log_probs = jax.nn.log_softmax(logits)
+    losses = -jnp.take_along_axis(log_probs, labels[:, None], axis=-1)[:, 0]
+    weights = jnp.asarray(mask, jnp.float32)
+    return jnp.sum(losses * weights) / jnp.maximum(jnp.sum(weights), 1)
diff --git a/src/repro_control/cnn_training.py b/src/repro_control/cnn_training.py
new file mode 100644
index 0000000000000000000000000000000000000000..c55f75016ba70f403d1b45afda2fb3b859a3a567
--- /dev/null
+++ b/src/repro_control/cnn_training.py
@@ -0,0 +1,120 @@
+"""Fixed-final-epoch trainer for the registered CNN family."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .checkpoints import save_checkpoint_atomic
+from .cnn import forward, init_params, kernel_weight_decay_mask, masked_sparse_cross_entropy
+from .configs import verify_before_optimizer
+from .hashing import atomic_write_json
+
+
+def train_fixed_cnn(
+    data_dir: Path,
+    output_dir: Path,
+    *,
+    seed: int,
+    registered_config: dict,
+    registered_config_sha256: str,
+) -> None:
+    import jax
+    import jax.numpy as jnp
+    import numpy as np
+    import optax
+
+    from sheaf_admm.data import ImageDataset
+
+    verify_before_optimizer(
+        registered_config,
+        registered_config,
+        expected_sha256=registered_config_sha256,
+    )
+    if registered_config["training"]["seed"] != seed:
+        raise ValueError("CNN seed differs from the registered config")
+    if Path(registered_config["data"]["dir"]) != data_dir:
+        raise ValueError("CNN data path differs from the registered config")
+    dataset = ImageDataset(data_dir, "train")
+    if dataset.num_examples != 60_000:
+        raise ValueError("registered CNN requires the full 60,000-example train set")
+    images = np.asarray(dataset.images, dtype=np.float32)
+    labels = np.asarray(dataset.labels, dtype=np.int32)
+    if images.shape[1:] != (28, 28, 1) or np.min(images) < 0 or np.max(images) > 1:
+        raise ValueError("registered CNN input must be [60000,28,28,1] float32 in [0,1]")
+
+    key = jax.random.PRNGKey(seed)
+    params = init_params(key)
+    schedule = optax.join_schedules(
+        [optax.linear_schedule(0.0, 1e-3, 200), optax.constant_schedule(1e-3)],
+        [200],
+    )
+    optimizer = optax.chain(
+        optax.clip_by_global_norm(1.0),
+        optax.adamw(
+            schedule,
+            b1=0.9,
+            b2=0.999,
+            eps=1e-8,
+            weight_decay=1e-7,
+            mask=kernel_weight_decay_mask(params),
+        ),
+    )
+    optimizer_state = optimizer.init(params)
+    ema = jax.tree_util.tree_map(jnp.copy, params)
+
+    @jax.jit
+    def step(params, optimizer_state, ema, batch_images, batch_labels, real_mask):
+        loss, grads = jax.value_and_grad(
+            lambda p: masked_sparse_cross_entropy(
+                forward(p, batch_images), batch_labels, real_mask
+            )
+        )(params)
+        updates, optimizer_state = optimizer.update(grads, optimizer_state, params)
+        params = optax.apply_updates(params, updates)
+        ema = jax.tree_util.tree_map(lambda e, p: 0.999 * e + 0.001 * p, ema, params)
+        return params, optimizer_state, ema, loss
+
+    history = []
+    for epoch in range(20):
+        permutation = np.asarray(jax.random.permutation(jax.random.fold_in(key, epoch), 60_000))
+        epoch_losses = []
+        for start in range(0, 60_000, 128):
+            indices = permutation[start : start + 128]
+            real = len(indices)
+            if real < 128:
+                indices = np.pad(indices, (0, 128 - real), constant_values=0)
+            mask = np.arange(128) < real
+            params, optimizer_state, ema, loss = step(
+                params,
+                optimizer_state,
+                ema,
+                images[indices],
+                labels[indices],
+                mask,
+            )
+            epoch_losses.append(float(loss))
+        history.append({"epoch": epoch, "mean_train_loss": float(np.mean(epoch_losses))})
+        output_dir.mkdir(parents=True, exist_ok=True)
+        save_checkpoint_atomic(
+            output_dir / "checkpoint.partial.pkl",
+            {
+                "params": jax.device_get(params),
+                "ema_params": jax.device_get(ema),
+                "optimizer_state": jax.device_get(optimizer_state),
+                "seed": seed,
+                "next_epoch": epoch + 1,
+                "model": "mnist_cnn_repro",
+            },
+        )
+        atomic_write_json(output_dir / "history.partial.json", history)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint = {
+        "params": jax.device_get(params),
+        "ema_params": jax.device_get(ema),
+        "optimizer_state": jax.device_get(optimizer_state),
+        "seed": seed,
+        "final_epoch": 19,
+        "model": "mnist_cnn_repro",
+    }
+    save_checkpoint_atomic(output_dir / "checkpoint.pkl", checkpoint)
+    atomic_write_json(output_dir / "history.json", history)
diff --git a/src/repro_control/configs.py b/src/repro_control/configs.py
new file mode 100644
index 0000000000000000000000000000000000000000..b7e344b04626823832adbaac9fc2f07065cdc484
--- /dev/null
+++ b/src/repro_control/configs.py
@@ -0,0 +1,194 @@
+"""Exact registered config expansion and pre-optimizer verification."""
+
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+from typing import Any
+
+from .hashing import compact_json_bytes, sha256_bytes
+
+
+class ConfigError(ValueError):
+    pass
+
+
+def _set_path(value: dict[str, Any], dotted: str, replacement: Any) -> None:
+    parts = dotted.split(".")
+    cursor = value
+    for part in parts[:-1]:
+        child = cursor.get(part)
+        if not isinstance(child, dict):
+            raise ConfigError(f"override path does not resolve: {dotted}")
+        cursor = child
+    if parts[-1] not in cursor:
+        raise ConfigError(f"override targets unknown key: {dotted}")
+    cursor[parts[-1]] = replacement
+
+
+def expand_exact(base: dict[str, Any], overrides: dict[str, Any]) -> dict[str, Any]:
+    result = copy.deepcopy(base)
+    for dotted in sorted(overrides):
+        _set_path(result, dotted, overrides[dotted])
+    return result
+
+
+def config_sha256(value: dict[str, Any]) -> str:
+    return sha256_bytes(compact_json_bytes(value))
+
+
+def verify_before_optimizer(
+    resolved: dict[str, Any],
+    expected: dict[str, Any],
+    *,
+    expected_sha256: str,
+) -> None:
+    if resolved != expected:
+        raise ConfigError("resolved config differs from the frozen expansion")
+    if config_sha256(resolved) != expected_sha256:
+        raise ConfigError("resolved config hash differs from the frozen expansion")
+    training = resolved.get("training", {})
+    data = resolved.get("data", {})
+    required = {
+        "batch_size": 128,
+        "warmup_steps": 200,
+        "grad_clip": 1.0,
+        "ema_decay": 0.999,
+    }
+    for name, expected_value in required.items():
+        if training.get(name) != expected_value:
+            raise ConfigError(f"training.{name} must equal {expected_value}")
+    if data.get("val_splits") != []:
+        raise ConfigError("training configuration must have data.val_splits=[]")
+    if resolved.get("dtype") != "float32":
+        raise ConfigError("scientific runs require float32")
+
+
+def load_json_config(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text())
+    if not isinstance(value, dict):
+        raise ConfigError("config root must be an object")
+    return value
+
+
+def compose_hydra_config(
+    project_root: Path,
+    *,
+    experiment: str,
+    seed: int,
+    data_dir: str,
+    overrides: tuple[str, ...] = (),
+) -> dict[str, Any]:
+    """Compose the exact public Hydra application config without running training."""
+    from hydra import compose, initialize_config_dir
+    from omegaconf import OmegaConf
+
+    config_dir = (project_root / "configs").resolve()
+    hydra_overrides = [
+        f"+experiment={experiment}",
+        f"training.seed={seed}",
+        f"data.dir={data_dir}",
+        "data.val_splits=[]",
+        "wandb.mode=disabled",
+        *overrides,
+    ]
+    with initialize_config_dir(config_dir=str(config_dir), version_base=None):
+        cfg = compose(config_name="config", overrides=hydra_overrides)
+    value = OmegaConf.to_container(cfg, resolve=True)
+    if not isinstance(value, dict):
+        raise ConfigError("Hydra expansion did not produce an object")
+    return value
+
+
+def cnn_registered_config(*, seed: int, data_dir: str) -> dict[str, Any]:
+    """Exact non-Hydra config consumed by the fixed MNIST CNN trainer."""
+    return {
+        "task": "mnist",
+        "model_type": "mnist_cnn_repro",
+        "dtype": "float32",
+        "wandb": {"mode": "disabled"},
+        "training": {
+            "seed": seed,
+            "lr": 0.001,
+            "weight_decay": 0.0000001,
+            "epochs": 20,
+            "batch_size": 128,
+            "warmup_steps": 200,
+            "grad_clip": 1.0,
+            "ema_decay": 0.999,
+            "betas": [0.9, 0.999],
+            "epsilon": 0.00000001,
+            "schedule": "linear_to_task_lr_then_constant",
+            "epoch_permutation": "fold_in(PRNGKey(seed),epoch)",
+            "final_batch": "pad_to_128_mask_normalize",
+            "selection": "fixed_final_epoch",
+        },
+        "data": {
+            "dir": data_dir,
+            "train_split": "train",
+            "val_splits": [],
+            "loader": "image",
+            "examples": 60000,
+            "normalization": False,
+            "augmentation": False,
+            "input_range": [0, 1],
+        },
+        "model": {
+            "layout": "NHWC/HWIO/NHWC",
+            "parameter_count": 65642,
+            "pre_pool_sizes": [28, 60],
+            "post_pool_sizes": [14, 30],
+        },
+        "task_cfg": {},
+    }
+
+
+def registered_config_for(
+    project_root: Path,
+    logical_id: str,
+    *,
+    data_root: str = "/data/train",
+) -> dict[str, Any]:
+    """Expand one of the exactly fifteen registered scientific identities."""
+    try:
+        seed = int(logical_id.rsplit("-", 1)[1])
+    except (IndexError, ValueError) as exc:
+        raise ConfigError(f"logical identity has no registered seed: {logical_id}") from exc
+    if seed not in (42, 123, 456):
+        raise ConfigError(f"unregistered seed in logical identity: {logical_id}")
+
+    if logical_id.startswith("C1-SUD-MPNN225-"):
+        return compose_hydra_config(
+            project_root,
+            experiment="sudoku_mpnn",
+            seed=seed,
+            data_dir=f"{data_root}/sudoku_easy",
+            overrides=("model.d_v=225", "training.lr=1.7e-3", "training.epochs=10"),
+        )
+    if logical_id.startswith("C2-MAZE-MPNN84-"):
+        return compose_hydra_config(
+            project_root,
+            experiment="maze_mpnn",
+            seed=seed,
+            data_dir=f"{data_root}/maze_std3_19px_10k",
+        )
+    if logical_id.startswith("C3-MNIST-CNN-"):
+        return cnn_registered_config(seed=seed, data_dir=f"{data_root}/mnist")
+    if logical_id.startswith("C4-SUD-IDENTITY-"):
+        return compose_hydra_config(
+            project_root,
+            experiment="sudoku_sheaf",
+            seed=seed,
+            data_dir=f"{data_root}/sudoku_easy",
+            overrides=("model.rm_init=identity", "+model.rm_constant=true"),
+        )
+    if logical_id.startswith("C4-MAZE-QUADRATIC-"):
+        return compose_hydra_config(
+            project_root,
+            experiment="maze_sheaf",
+            seed=seed,
+            data_dir=f"{data_root}/maze_std3_19px_10k",
+            overrides=("model.objective_mode=quadratic",),
+        )
+    raise ConfigError(f"unregistered training logical identity: {logical_id}")
diff --git a/src/repro_control/constants.py b/src/repro_control/constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..c544c0fb24449361ef122b7651e3d83332bd5d9d
--- /dev/null
+++ b/src/repro_control/constants.py
@@ -0,0 +1,12 @@
+"""Frozen public constants baked into every reproduction entrypoint."""
+
+SCIENCE_SPEC_SHA256 = "c0ded12138cb7c15a15966294ed9bdb87d3a66d2373a7d90050578dbb973c6fd"
+DEADLINE_UTC = "2026-08-03T11:59:00Z"
+NOT_APPLICABLE = "NOT_APPLICABLE"
+REGISTERED_SEEDS = (42, 123, 456)
+NORMAL_CAP_MICRO_USD = 75_000_000
+GPU_RETRY_RESERVE_MICRO_USD = 10_000_000
+MINIMUM_BALANCE_MICRO_USD = 10_000_000
+MAX_RETURNED_IDS = 29
+MAX_GPU_RETURNED_IDS = 26
+MAX_CPU_RETURNED_IDS = 3
diff --git a/src/repro_control/data.py b/src/repro_control/data.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f47d8e8ca51c97a992ad437ec8858510cec428a
--- /dev/null
+++ b/src/repro_control/data.py
@@ -0,0 +1,271 @@
+"""Registered corruption masks, long-path data, and smoke fixture checks."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import random
+from collections.abc import Iterable
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from .hashing import atomic_write_json, compact_json_bytes, sha256_bytes
+
+MNIST_AGENT_COUNT = 81
+MNIST_DROP_COUNT = 24
+MNIST_DROPOUT_MASTER_SEED = 21005300
+C5_SIZES = (19, 23, 27, 31, 35, 39)
+
+
+def derived_seed(*parts: object) -> int:
+    material = "\0".join(str(part) for part in parts).encode()
+    return int.from_bytes(hashlib.sha256(material).digest()[:8], "big")
+
+
+def mnist_keep_mask(
+    dataset_revision: str,
+    example_id: int,
+    condition: str = "drop30",
+    master_seed: int = MNIST_DROPOUT_MASTER_SEED,
+) -> tuple[bool, ...]:
+    if condition != "drop30":
+        raise ValueError("registered dropout mask condition is drop30")
+    rng = random.Random(derived_seed(dataset_revision, example_id, condition, master_seed))
+    removed = frozenset(rng.sample(range(MNIST_AGENT_COUNT), MNIST_DROP_COUNT))
+    mask = tuple(index not in removed for index in range(MNIST_AGENT_COUNT))
+    if sum(mask) != MNIST_AGENT_COUNT - MNIST_DROP_COUNT:
+        raise AssertionError("dropout mask cardinality failure")
+    return mask
+
+
+def build_mnist_mask_bank(
+    dataset_revision: str,
+    example_ids: Iterable[int],
+    *,
+    master_seed: int = MNIST_DROPOUT_MASTER_SEED,
+) -> dict:
+    ids = list(example_ids)
+    if len(ids) != len(set(ids)):
+        raise ValueError("example IDs must be unique")
+    entries = [
+        {
+            "example_id": example_id,
+            "keep_mask": mnist_keep_mask(
+                dataset_revision,
+                example_id,
+                master_seed=master_seed,
+            ),
+        }
+        for example_id in ids
+    ]
+    serializable = [
+        {"example_id": row["example_id"], "keep_mask": [int(value) for value in row["keep_mask"]]}
+        for row in entries
+    ]
+    return {
+        "format": 1,
+        "dataset_revision": dataset_revision,
+        "condition": "drop30",
+        "master_seed": master_seed,
+        "entries": serializable,
+        "bank_sha256": sha256_bytes(compact_json_bytes(serializable)),
+    }
+
+
+def write_mnist_mask_bank(path: Path, bank: dict) -> None:
+    for row in bank["entries"]:
+        if len(row["keep_mask"]) != MNIST_AGENT_COUNT or sum(row["keep_mask"]) != 57:
+            raise ValueError("invalid registered mask bank")
+    atomic_write_json(path, bank)
+
+
+def apply_patch_dropout(images, keep_masks):
+    """Apply 9x9-agent 3x3 patch dropout; NumPy is imported only when invoked."""
+    import numpy as np
+
+    array = np.asarray(images)
+    masks = np.asarray(keep_masks, dtype=bool)
+    if array.ndim != 4 or array.shape[1:] != (28, 28, 1):
+        raise ValueError("images must have shape [B,28,28,1]")
+    if masks.shape != (array.shape[0], 81) or not np.all(masks.sum(axis=1) == 57):
+        raise ValueError("keep masks must be [B,81] with exactly 57 kept agents")
+    padded = np.pad(array, ((0, 0), (0, 2), (0, 2), (0, 0)))
+    result = padded.copy()
+    for agent in range(81):
+        row, col = divmod(agent, 9)
+        result[:, row * 3 : row * 3 + 3, col * 3 : col * 3 + 3, :] *= masks[
+            :, agent, None, None, None
+        ]
+    return result[:, :28, :28, :]
+
+
+def kept_edge_mask(edge_indices, keep_masks):
+    """Remove all incident edges for dropped agents."""
+    import numpy as np
+
+    edges = np.asarray(edge_indices)
+    masks = np.asarray(keep_masks, dtype=bool)
+    if edges.ndim != 2 or edges.shape[1] != 2:
+        raise ValueError("edge_indices must have shape [E,2]")
+    return masks[:, edges[:, 0]] & masks[:, edges[:, 1]]
+
+
+@dataclass(frozen=True)
+class C5Unit:
+    size: int
+    generator_seed: int
+    min_path_length: int
+    examples: int = 1000
+    iterations: int = 100
+
+
+def c5_units() -> tuple[C5Unit, ...]:
+    return tuple(
+        C5Unit(
+            size=size,
+            generator_seed=21005000 + size,
+            min_path_length=3 * (size - 1) // 2,
+        )
+        for size in C5_SIZES
+    )
+
+
+def canonical_maze_identity(inputs, labels) -> str:
+    """Hash canonical wall/start/goal/path bytes for overlap rejection."""
+    import numpy as np
+
+    inputs_array = np.asarray(inputs, dtype=np.uint8).reshape(-1)
+    labels_array = np.asarray(labels, dtype=np.uint8).reshape(-1)
+    return sha256_bytes(inputs_array.tobytes() + b"\0" + labels_array.tobytes())
+
+
+def generate_c5_size(
+    size: int,
+    *,
+    training_identities: frozenset[str],
+    examples: int = 1000,
+):
+    """Generate unique registered long-path examples using the released DFS builder."""
+    import numpy as np
+
+    from sheaf_admm.data.build_maze import (
+        _backtrack_maze,
+        _paint_grid,
+        _pick_positions,
+        _shortest_path,
+    )
+
+    if size not in C5_SIZES:
+        raise ValueError(f"unregistered C5 size {size}")
+    rng = np.random.default_rng(21005000 + size)
+    minimum = 3 * (size - 1) // 2
+    seen = set(training_identities)
+    inputs, labels = [], []
+    attempts = 0
+    while len(inputs) < examples:
+        attempts += 1
+        if attempts > examples * 10000:
+            raise RuntimeError("C5 generator exhausted deterministic replacement guard")
+        base = _backtrack_maze(size, size, rng)
+        start, goal = _pick_positions(base, rng)
+        path = _shortest_path(base, start, goal)
+        if len(path) - 1 < minimum:
+            continue
+        input_grid = _paint_grid(base, start, goal, path, with_path=False)
+        label_grid = _paint_grid(base, start, goal, path, with_path=True)
+        identity = canonical_maze_identity(input_grid, label_grid)
+        if identity in seen:
+            continue
+        seen.add(identity)
+        inputs.append(input_grid.reshape(-1).astype(np.uint8))
+        labels.append(label_grid.reshape(-1).astype(np.uint8))
+    arrays = {"inputs": np.stack(inputs), "labels": np.stack(labels)}
+    manifest = {
+        "format": 1,
+        "unit": asdict(
+            C5Unit(
+                size=size,
+                generator_seed=21005000 + size,
+                min_path_length=minimum,
+                examples=examples,
+            )
+        ),
+        "attempts": attempts,
+        "identity_root_sha256": sha256_bytes(
+            compact_json_bytes(
+                [canonical_maze_identity(x, y) for x, y in zip(inputs, labels, strict=True)]
+            )
+        ),
+    }
+    return arrays, manifest
+
+
+def deterministic_lpt(costs: dict[int, float]) -> dict[str, list[int]]:
+    if set(costs) != set(C5_SIZES) or any(value <= 0 for value in costs.values()):
+        raise ValueError("costs must cover all registered sizes with positive values")
+    shards: dict[str, list[int]] = {"A": [], "B": []}
+    totals = {"A": 0.0, "B": 0.0}
+    for size in sorted(C5_SIZES, key=lambda n: (-costs[n], n)):
+        shard = "A" if totals["A"] <= totals["B"] else "B"
+        shards[shard].append(size)
+        totals[shard] += costs[size]
+    return shards
+
+
+def validate_smoke_fixture_registry(registry_path: Path) -> None:
+    registry = json.loads(registry_path.read_text())
+    if registry["purpose"].lower().find("verdict metrics are forbidden") < 0:
+        raise ValueError("smoke fixture registry must forbid verdict metrics")
+    final_seeds = {21005300, *(21005000 + n for n in C5_SIZES)}
+    smoke_seeds = {91005101, 91005301, *(91005200 + n for n in C5_SIZES)}
+    if final_seeds & smoke_seeds:
+        raise ValueError("smoke and final generator seeds overlap")
+    for row in registry["entries"]:
+        if not row["path"].startswith("smoke-fixtures/"):
+            raise ValueError("unregistered smoke fixture path")
+
+
+def write_puzzle_split(
+    root: Path,
+    split: str,
+    inputs,
+    labels,
+    *,
+    height: int,
+    width: int,
+) -> None:
+    """Write one-example-per-puzzle arrays in the released PuzzleDataset format."""
+    import numpy as np
+
+    from sheaf_admm.data.common import PuzzleDatasetMetadata, save_npy
+
+    input_array = np.asarray(inputs, dtype=np.uint8)
+    label_array = np.asarray(labels, dtype=np.uint8)
+    if (
+        input_array.ndim != 2
+        or input_array.shape != label_array.shape
+        or input_array.shape[1] != height * width
+    ):
+        raise ValueError("puzzle arrays do not match the registered board dimensions")
+    count = len(input_array)
+    split_root = root / split
+    offsets = np.arange(count + 1, dtype=np.int32)
+    save_npy(split_root / "all__inputs.npy", input_array)
+    save_npy(split_root / "all__labels.npy", label_array)
+    save_npy(split_root / "all__puzzle_indices.npy", offsets)
+    save_npy(split_root / "all__group_indices.npy", offsets)
+    save_npy(split_root / "all__puzzle_identifiers.npy", np.zeros(count, dtype=np.int32))
+    PuzzleDatasetMetadata(
+        pad_id=0,
+        ignore_label_id=0,
+        blank_identifier_id=0,
+        vocab_size=6,
+        seq_len=height * width,
+        num_puzzle_identifiers=1,
+        total_groups=count,
+        mean_puzzle_examples=1.0,
+        total_puzzles=count,
+        sets=["all"],
+        height=height,
+        width=width,
+    ).write(split_root / "dataset.json")
diff --git a/src/repro_control/evaluation.py b/src/repro_control/evaluation.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5235f8f8df479ac8130d27c68fe152030d61766
--- /dev/null
+++ b/src/repro_control/evaluation.py
@@ -0,0 +1,398 @@
+"""EMA-only evaluation backends for fused logical suites and C5 shards."""
+
+from __future__ import annotations
+
+import json
+import pickle
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any
+
+from .cnn import forward as cnn_forward
+from .data import apply_patch_dropout
+from .hashing import atomic_write_json, compact_json_bytes, sha256_bytes, sha256_file
+
+
+class EvaluationError(ValueError):
+    pass
+
+
+def _load_pickle(path: Path) -> dict[str, Any]:
+    with path.open("rb") as handle:
+        value = pickle.load(handle)
+        if handle.read(1):
+            raise EvaluationError("checkpoint has trailing bytes")
+    if not isinstance(value, dict) or value.get("ema_params") is None:
+        raise EvaluationError("evaluation requires a checkpoint with EMA parameters")
+    return value
+
+
+def _puzzle_batches(dataset_dir: Path, split: str, batch_size: int):
+    import numpy as np
+
+    from sheaf_admm.data import PuzzleDataset
+
+    dataset = PuzzleDataset(dataset_dir, split)
+    for _set, batch in dataset.iter_test_batches(batch_size):
+        out = {"inputs": np.asarray(batch["inputs"]), "labels": np.asarray(batch["labels"])}
+        for name in ("height", "width"):
+            if name in batch:
+                out[name] = batch[name]
+        yield out
+
+
+def _fixed_puzzle_batches(
+    dataset_dir: Path,
+    split: str,
+    batch_size: int,
+) -> Iterator[tuple[dict[str, Any], int]]:
+    import numpy as np
+
+    from sheaf_admm.data import PuzzleDataset
+
+    dataset = PuzzleDataset(dataset_dir, split)
+    if set(dataset.sets) != {"all"}:
+        raise EvaluationError("registered C5 split requires exactly the all set")
+    puzzle_set = dataset.sets["all"]
+    for start in range(0, puzzle_set.num_examples, batch_size):
+        stop = min(start + batch_size, puzzle_set.num_examples)
+        real = stop - start
+        inputs = np.asarray(puzzle_set.inputs[start:stop])
+        labels = np.asarray(puzzle_set.labels[start:stop])
+        if real < batch_size:
+            inputs = np.pad(inputs, ((0, batch_size - real), (0, 0)))
+            labels = np.pad(labels, ((0, batch_size - real), (0, 0)))
+        yield (
+            {
+                "inputs": inputs,
+                "labels": labels,
+                "height": dataset.metadata.height,
+                "width": dataset.metadata.width,
+            },
+            real,
+        )
+
+
+def _load_mask_bank(path: Path, expected_sha256: str) -> dict[int, list[int]]:
+    value = json.loads(path.read_text())
+    if value.get("bank_sha256") != expected_sha256:
+        raise EvaluationError("MNIST mask bank hash differs from the unit manifest")
+    entries = value.get("entries")
+    if not isinstance(entries, list):
+        raise EvaluationError("invalid MNIST mask bank")
+    if sha256_bytes(compact_json_bytes(entries)) != expected_sha256:
+        raise EvaluationError("MNIST mask bank content hash mismatch")
+    bank = {int(row["example_id"]): row["keep_mask"] for row in entries}
+    if len(bank) != len(entries):
+        raise EvaluationError("duplicate MNIST mask example ID")
+    return bank
+
+
+def _image_batches(
+    dataset_dir: Path,
+    split: str,
+    batch_size: int,
+    *,
+    condition: str,
+    mask_bank_path: str = "",
+    mask_bank_sha256: str = "",
+) -> Iterator[dict[str, Any]]:
+    import numpy as np
+
+    from sheaf_admm.data import ImageDataset
+
+    dataset = ImageDataset(dataset_dir, split)
+    mask_bank = (
+        _load_mask_bank(Path(mask_bank_path), mask_bank_sha256)
+        if condition == "drop30"
+        else None
+    )
+    for start in range(0, dataset.num_examples, batch_size):
+        stop = min(start + batch_size, dataset.num_examples)
+        images = np.asarray(dataset.images[start:stop], dtype=np.float32)
+        labels = np.asarray(dataset.labels[start:stop])
+        if images.shape[1:] != (28, 28, 1):
+            raise EvaluationError("registered MNIST source split must be clean 28x28")
+        batch: dict[str, Any] = {"images": images, "labels": labels}
+        if condition == "pad16":
+            batch["images"] = np.pad(images, ((0, 0), (16, 16), (16, 16), (0, 0)))
+        elif condition == "drop30":
+            assert mask_bank is not None
+            masks = np.asarray([mask_bank[index] for index in range(start, stop)], dtype=bool)
+            batch["images"] = apply_patch_dropout(images, masks)
+            batch["keep_masks"] = masks
+        elif condition != "clean":
+            raise EvaluationError(f"unsupported MNIST condition {condition!r}")
+        yield batch
+
+
+def _upstream_backend(unit: dict[str, Any]):
+    import jax
+
+    from sheaf_admm.models import model_config_from_dict
+    from sheaf_admm.training import build_model, make_task
+    from sheaf_admm.training.loop import _forward
+
+    checkpoint_path = Path(unit["checkpoint_path"])
+    config_path = Path(unit["config_path"])
+    checkpoint = _load_pickle(checkpoint_path)
+    config = json.loads(config_path.read_text())
+    model_config = model_config_from_dict(config["model"])
+    model = build_model(model_config, config["model_type"])
+    task = make_task(config["task"], **config["task_cfg"])
+    params = checkpoint["ema_params"]
+    graph_readout = model_config.mpnn_graph_readout
+    model_type = config["model_type"]
+    k_eval = (
+        config["training"]["K_eval"]
+        if model_type == "sheaf"
+        else config["training"]["mpnn_eval_rounds"]
+    )
+
+    @jax.jit
+    def forward(current_params, fwd):
+        return _forward(
+            model.apply,
+            current_params,
+            fwd,
+            n_iter=k_eval,
+            loss_window=1,
+            model_type=model_type,
+            training=False,
+            rng=None,
+        )
+
+    return (
+        checkpoint_path,
+        config_path,
+        params,
+        task,
+        graph_readout,
+        model_type,
+        forward,
+    )
+
+
+def evaluate_upstream_unit(unit: dict[str, Any]) -> dict[str, Any]:
+    import jax
+
+    (
+        checkpoint_path,
+        config_path,
+        params,
+        task,
+        graph_readout,
+        model_type,
+        forward,
+    ) = _upstream_backend(unit)
+
+    dataset_dir = Path(unit["dataset_dir"])
+    config = json.loads(config_path.read_text())
+    if config["data"]["loader"] == "image":
+        batches = _image_batches(
+            dataset_dir,
+            unit["split"],
+            128,
+            condition=unit["condition"],
+            mask_bank_path=unit.get("mask_bank_path", ""),
+            mask_bank_sha256=unit.get("mask_bank_sha256", ""),
+        )
+    else:
+        batches = _puzzle_batches(dataset_dir, unit["split"], 128)
+    totals: dict[str, float] = {}
+    count = 0
+    for batch in batches:
+        fwd, targets, aux = task.prepare(batch)
+        logits = forward(params, fwd)
+        jax.block_until_ready(logits)
+        final = logits if model_type == "mpnn" else logits[-1]
+        metrics = (
+            task.evaluate_graph(final, targets, aux)
+            if model_type == "mpnn" and graph_readout == "graph"
+            else task.evaluate(final, targets, aux)
+        )
+        weight = len(batch["labels"])
+        for name, value in metrics.items():
+            totals[name] = totals.get(name, 0.0) + float(value) * weight
+        count += weight
+    if count == 0:
+        raise EvaluationError("evaluation unit contained no examples")
+    return {
+        "neutral_id": unit["neutral_id"],
+        "seed": unit["seed"],
+        "condition": unit["condition"],
+        "examples": count,
+        "metrics": {name: value / count for name, value in sorted(totals.items())},
+        "checkpoint_sha256": sha256_file(checkpoint_path),
+        "config_sha256": sha256_file(config_path),
+        "ema": True,
+    }
+
+
+def evaluate_cnn_unit(unit: dict[str, Any]) -> dict[str, Any]:
+    import jax
+    import numpy as np
+
+    checkpoint_path = Path(unit["checkpoint_path"])
+    config_path = Path(unit["config_path"])
+    checkpoint = _load_pickle(checkpoint_path)
+    params = checkpoint["ema_params"]
+    run = jax.jit(cnn_forward)
+    correct = count = 0
+    for batch in _image_batches(
+        Path(unit["dataset_dir"]),
+        unit["split"],
+        128,
+        condition=unit["condition"],
+        mask_bank_path=unit.get("mask_bank_path", ""),
+        mask_bank_sha256=unit.get("mask_bank_sha256", ""),
+    ):
+        logits = run(params, batch["images"])
+        predictions = np.asarray(jax.device_get(logits.argmax(axis=-1)))
+        labels = np.asarray(batch["labels"])
+        correct += int(np.sum(predictions == labels))
+        count += len(labels)
+    if count == 0:
+        raise EvaluationError("CNN evaluation unit contained no examples")
+    return {
+        "neutral_id": unit["neutral_id"],
+        "seed": unit["seed"],
+        "condition": unit["condition"],
+        "examples": count,
+        "metrics": {"acc": correct / count},
+        "checkpoint_sha256": sha256_file(checkpoint_path),
+        "config_sha256": sha256_file(config_path),
+        "ema": True,
+    }
+
+
+def evaluate_c5_size(units: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    import jax
+    import jax.numpy as jnp
+
+    from sheaf_admm.data import views
+    from sheaf_admm.models import model_config_from_dict
+    from sheaf_admm.training import build_model, make_task
+    from sheaf_admm.training.loop import _forward
+
+    if len(units) != 3 or {unit["seed"] for unit in units} != {42, 123, 456}:
+        raise EvaluationError("each C5 size requires exactly the three registered seeds")
+    first = units[0]
+    config = json.loads(Path(first["config_path"]).read_text())
+    model_config = model_config_from_dict(config["model"])
+    model = build_model(model_config, "sheaf")
+    task = make_task("maze", **config["task_cfg"])
+    batch_size = int(first["batch_size"])
+    if any(
+        int(unit["batch_size"]) != batch_size
+        or unit["dataset_dir"] != first["dataset_dir"]
+        or unit["split"] != first["split"]
+        for unit in units
+    ):
+        raise EvaluationError("C5 size units disagree on data or frozen batch size")
+
+    @jax.jit
+    def forward(params, fwd):
+        logits = _forward(
+            model.apply,
+            params,
+            fwd,
+            n_iter=100,
+            loss_window=1,
+            model_type="sheaf",
+            training=False,
+            rng=None,
+        )
+        return logits[-1]
+
+    batches = list(
+        _fixed_puzzle_batches(
+            Path(first["dataset_dir"]),
+            first["split"],
+            batch_size,
+        )
+    )
+    if sum(real for _, real in batches) != 1000:
+        raise EvaluationError("registered C5 unit must contain exactly 1000 real examples")
+    results = []
+    for unit in sorted(units, key=lambda row: row["seed"]):
+        checkpoint_path = Path(unit["checkpoint_path"])
+        config_path = Path(unit["config_path"])
+        params = _load_pickle(checkpoint_path)["ema_params"]
+        solved_count = cell_correct = cell_count = example_count = 0
+        for batch, real in batches:
+            fwd, targets, aux = task.prepare(batch)
+            logits = forward(params, fwd)
+            jax.block_until_ready(logits)
+            reconstructed = jnp.asarray(
+                views.reassemble_logits(
+                    logits,
+                    aux["centers"],
+                    aux["image_hw"],
+                    model_config.num_classes,
+                    mode="mean",
+                )
+            )
+            predictions = jnp.argmax(reconstructed, axis=-1)[:real]
+            labels = targets["labels_img"][:real]
+            solved = jnp.all(
+                (predictions == 5) == (labels == 5),
+                axis=(1, 2),
+            )
+            solved_count += int(jnp.sum(solved))
+            cell_correct += int(jnp.sum(predictions == labels))
+            cell_count += int(labels.size)
+            example_count += real
+        results.append(
+            {
+                "neutral_id": unit["neutral_id"],
+                "seed": unit["seed"],
+                "condition": "c5",
+                "size": unit["size"],
+                "examples": example_count,
+                "metrics": {
+                    "solved": solved_count / example_count,
+                    "cell_acc": cell_correct / cell_count,
+                },
+                "checkpoint_sha256": sha256_file(checkpoint_path),
+                "config_sha256": sha256_file(config_path),
+                "ema": True,
+                "batch_size": batch_size,
+                "padded_tail_excluded": True,
+            }
+        )
+    return results
+
+
+def evaluate_units(unit_manifest_path: Path, output_path: Path) -> None:
+    manifest = json.loads(unit_manifest_path.read_text())
+    if set(manifest) != {"format", "units"} or manifest["format"] != 1:
+        raise EvaluationError("invalid evaluator unit manifest")
+    identities = [unit["neutral_id"] for unit in manifest["units"]]
+    if len(identities) != len(set(identities)):
+        raise EvaluationError("duplicate evaluator unit identity")
+    results = []
+    c5_by_size: dict[int, list[dict[str, Any]]] = {}
+    for unit in manifest["units"]:
+        if unit["condition"] not in {"clean", "pad16", "drop30", "c5"}:
+            raise EvaluationError("unregistered evaluation condition")
+        if unit["condition"] == "c5":
+            c5_by_size.setdefault(int(unit["size"]), []).append(unit)
+        else:
+            result = (
+                evaluate_cnn_unit(unit)
+                if unit["model_kind"] == "mnist_cnn_repro"
+                else evaluate_upstream_unit(unit)
+            )
+            results.append(result)
+    for size in sorted(c5_by_size):
+        results.extend(evaluate_c5_size(c5_by_size[size]))
+    atomic_write_json(
+        output_path,
+        {
+            "format": 1,
+            "unit_manifest_sha256": sha256_file(unit_manifest_path),
+            "units": results,
+            "verdicts": {},
+        },
+    )
diff --git a/src/repro_control/hashing.py b/src/repro_control/hashing.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7a5f3ec0c8980f25fc0b4122fda7de5186f9767
--- /dev/null
+++ b/src/repro_control/hashing.py
@@ -0,0 +1,68 @@
+"""Canonical hashing and atomic local writes."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any, Iterable
+
+
+def sha256_bytes(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def compact_json_bytes(value: Any) -> bytes:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
+
+
+def canonical_root(entries: Iterable[dict[str, Any]]) -> str:
+    rows = sorted(entries, key=lambda row: row["path"])
+    return sha256_bytes(compact_json_bytes(rows))
+
+
+def file_entry(path: Path, *, relative_to: Path) -> dict[str, Any]:
+    return {
+        "path": path.relative_to(relative_to).as_posix(),
+        "bytes": path.stat().st_size,
+        "sha256": sha256_file(path),
+    }
+
+
+def tree_entries(root: Path, *, excluded_names: frozenset[str] = frozenset()) -> list[dict]:
+    return [
+        file_entry(path, relative_to=root)
+        for path in sorted(root.rglob("*"))
+        if path.is_file() and not any(part in excluded_names for part in path.relative_to(root).parts)
+    ]
+
+
+def atomic_write_bytes(path: Path, data: bytes) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+    try:
+        with os.fdopen(descriptor, "wb") as handle:
+            handle.write(data)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+    except BaseException:
+        try:
+            os.unlink(temporary)
+        except FileNotFoundError:
+            pass
+        raise
+
+
+def atomic_write_json(path: Path, value: Any) -> None:
+    atomic_write_bytes(path, json.dumps(value, indent=2, sort_keys=True).encode() + b"\n")
diff --git a/src/repro_control/heartbeat.py b/src/repro_control/heartbeat.py
new file mode 100644
index 0000000000000000000000000000000000000000..056279d373a455c88e61b8b98b5c6a5691a25cb8
--- /dev/null
+++ b/src/repro_control/heartbeat.py
@@ -0,0 +1,30 @@
+"""Line-buffered readiness and heartbeat markers for supervised HF Jobs."""
+
+from __future__ import annotations
+
+import threading
+from collections.abc import Iterator
+from contextlib import contextmanager
+from datetime import UTC, datetime
+
+
+def marker(name: str, detail: str = "") -> None:
+    suffix = f" {detail}" if detail else ""
+    print(f"{name} {datetime.now(UTC).isoformat()}{suffix}", flush=True)
+
+
+@contextmanager
+def heartbeat(stage: str, *, interval_seconds: int = 60) -> Iterator[None]:
+    stop = threading.Event()
+
+    def emit() -> None:
+        while not stop.wait(interval_seconds):
+            marker("HEARTBEAT", stage)
+
+    worker = threading.Thread(target=emit, name=f"heartbeat-{stage}", daemon=True)
+    worker.start()
+    try:
+        yield
+    finally:
+        stop.set()
+        worker.join(timeout=1)
diff --git a/src/repro_control/hf_provider.py b/src/repro_control/hf_provider.py
new file mode 100644
index 0000000000000000000000000000000000000000..53c6e296a67d52177433d37cf766c0d6dcf92039
--- /dev/null
+++ b/src/repro_control/hf_provider.py
@@ -0,0 +1,179 @@
+"""Hugging Face Jobs adapter for the durable direct-launch state machine."""
+
+from __future__ import annotations
+
+import math
+import re
+from datetime import UTC, datetime
+from typing import Any
+
+from huggingface_hub import HfApi, Volume
+from huggingface_hub.errors import HfHubHTTPError
+from requests import RequestException
+
+from .launcher import AmbiguousSubmission, LaunchError
+
+MARKER_TIME = re.compile(
+    r"\b(?P<marker>CPU_READY|GPU_READY|HEARTBEAT|DONE)\s+"
+    r"(?P<time>\d{4}-\d{2}-\d{2}T[^\s]+)"
+)
+
+
+def _iso(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, datetime):
+        return value.astimezone(UTC).isoformat()
+    return str(value)
+
+
+class HFJobsProvider:
+    def __init__(self, *, namespace: str = "Mindcraft", api: HfApi | None = None):
+        self.namespace = namespace
+        self.api = api or HfApi()
+
+    @staticmethod
+    def _volumes(rows: list[dict[str, Any]]) -> list[Volume]:
+        volumes = []
+        for row in rows:
+            volumes.append(
+                Volume(
+                    type="bucket",
+                    source=row["volume_source"],
+                    path=row["volume_path"] or None,
+                    mount_path=row["mount_path"],
+                    read_only=row["read_only"],
+                )
+            )
+        return volumes
+
+    @staticmethod
+    def _assert_no_credentials(request: dict[str, Any]) -> None:
+        if request.get("secrets"):
+            raise LaunchError("Jobs may not receive provider secrets under TRACE_MODE=none")
+        env = request.get("env") or {}
+        forbidden = ("TOKEN", "SECRET", "PASSWORD", "AUTHORIZATION", "API_KEY")
+        matches = [name for name in env if any(term in name.upper() for term in forbidden)]
+        if matches:
+            raise LaunchError(f"credential-like Job environment names are forbidden: {matches}")
+
+    def submit(self, request: dict[str, Any]) -> dict[str, Any]:
+        self._assert_no_credentials(request)
+        labels = {
+            "repro-attempt": request["label"],
+            "logical-id": request["logical_id"],
+            "job-class": request["job_class"],
+        }
+        try:
+            info = self.api.run_job(
+                image=request["image"],
+                command=request["command"],
+                env=request.get("env") or {},
+                secrets=None,
+                flavor=request["flavor"],
+                timeout=request["timeout_seconds"],
+                labels=labels,
+                volumes=self._volumes(request.get("mounts", [])),
+                namespace=self.namespace,
+            )
+        except HfHubHTTPError as exc:
+            status = getattr(exc.response, "status_code", None)
+            if status is not None and 400 <= status < 500 and status not in {408, 429}:
+                raise LaunchError(
+                    f"provider rejected Job before acceptance: HTTP {status}"
+                ) from exc
+            raise AmbiguousSubmission("provider response is ambiguous; reconcile by label") from exc
+        except (RequestException, TimeoutError, ConnectionError) as exc:
+            raise AmbiguousSubmission("provider response is ambiguous; reconcile by label") from exc
+        return self._normalize_identity(info)
+
+    def find_by_label(self, label: str) -> list[dict[str, Any]]:
+        return [
+            self._normalize_identity(info)
+            for info in self.api.list_jobs(namespace=self.namespace)
+            if (info.labels or {}).get("repro-attempt") == label
+        ]
+
+    def get(self, job_id: str) -> dict[str, Any]:
+        info = self.api.inspect_job(job_id=job_id, namespace=self.namespace)
+        logs = self._logs(job_id)
+        stage = getattr(info.status.stage, "value", str(info.status.stage))
+        states = {
+            "SCHEDULING": "STARTING",
+            "RUNNING": "RUNNING",
+            "COMPLETED": "COMPLETED",
+            "ERROR": "FAILED",
+            "CANCELED": "CANCELED",
+            "DELETED": "FAILED",
+        }
+        if stage not in states:
+            raise LaunchError(f"unrecognized Hugging Face Job stage {stage!r}")
+        ready_times = []
+        heartbeat_times = []
+        done_times = []
+        for line in logs:
+            for match in MARKER_TIME.finditer(line):
+                try:
+                    parsed = datetime.fromisoformat(match.group("time").replace("Z", "+00:00"))
+                except ValueError:
+                    continue
+                marker = match.group("marker")
+                if marker in {"CPU_READY", "GPU_READY"}:
+                    ready_times.append(parsed)
+                elif marker == "HEARTBEAT":
+                    heartbeat_times.append(parsed)
+                elif marker == "DONE":
+                    done_times.append(parsed)
+        duration = getattr(info, "durations", None)
+        running_seconds = getattr(duration, "running_secs", None)
+        normalized = {
+            "state": states[stage],
+            "provider_stage": stage,
+            "provider_message": info.status.message,
+            "starting_at": _iso(info.started_at),
+            "started_at": _iso(info.started_at),
+            "finished_at": _iso(info.finished_at),
+            "ready_marker": bool(ready_times),
+            "ready_at": _iso(min(ready_times)) if ready_times else "",
+            "heartbeat": bool(heartbeat_times),
+            "heartbeat_at": _iso(max(heartbeat_times)) if heartbeat_times else "",
+            "done_marker": bool(done_times),
+            "done_at": _iso(max(done_times)) if done_times else "",
+            "billable_duration_seconds": (
+                max(0, math.ceil(float(running_seconds)))
+                if running_seconds is not None
+                and states[stage] in {"COMPLETED", "FAILED", "CANCELED"}
+                else None
+            ),
+            "logs_tail": logs[-200:],
+        }
+        return normalized
+
+    def cancel(self, job_id: str) -> None:
+        self.api.cancel_job(job_id=job_id, namespace=self.namespace)
+
+    def _logs(self, job_id: str) -> list[str]:
+        try:
+            return list(
+                self.api.fetch_job_logs(
+                    job_id=job_id,
+                    namespace=self.namespace,
+                    follow=False,
+                    tail=1000,
+                )
+            )
+        except HfHubHTTPError as exc:
+            status = getattr(exc.response, "status_code", None)
+            if status in {404, 409}:
+                return []
+            raise
+
+    @staticmethod
+    def _normalize_identity(info: Any) -> dict[str, Any]:
+        job_id = str(info.id)
+        url = str(info.url or f"https://huggingface.co/jobs/{job_id}")
+        return {
+            "job_id": job_id,
+            "job_url": url,
+            "state": "SUBMITTED",
+        }
diff --git a/src/repro_control/interventions.py b/src/repro_control/interventions.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b123720b432e3986a1f7934ceab538d255d4689
--- /dev/null
+++ b/src/repro_control/interventions.py
@@ -0,0 +1,93 @@
+"""Bit-identity checks for the registered literal Sudoku intervention."""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Mapping
+from typing import Any
+
+import jax
+import numpy as np
+
+
+class InterventionError(ValueError):
+    pass
+
+
+def without_restriction_map(tree: Any) -> Any:
+    """Return a structurally equivalent tree with every named ``rm`` subtree removed."""
+    if isinstance(tree, Mapping):
+        return {
+            key: without_restriction_map(value)
+            for key, value in tree.items()
+            if key not in {"rm", "restriction_maps", "R_indices"}
+        }
+    if isinstance(tree, list):
+        return [without_restriction_map(value) for value in tree]
+    if isinstance(tree, tuple):
+        return tuple(without_restriction_map(value) for value in tree)
+    return tree
+
+
+def stable_tree_digest(tree: Any) -> str:
+    """Digest semantic containers and array bytes without device/container metadata."""
+    digest = hashlib.sha256()
+
+    def visit(value: Any) -> None:
+        if isinstance(value, Mapping):
+            digest.update(b"M{")
+            for key in sorted(value, key=lambda item: str(item)):
+                encoded = str(key).encode()
+                digest.update(len(encoded).to_bytes(8, "big"))
+                digest.update(encoded)
+                visit(value[key])
+            digest.update(b"}")
+            return
+        if isinstance(value, (list, tuple)):
+            digest.update(b"S[")
+            digest.update(len(value).to_bytes(8, "big"))
+            for item in value:
+                visit(item)
+            digest.update(b"]")
+            return
+        array = np.asarray(jax.device_get(value))
+        digest.update(b"A")
+        digest.update(array.dtype.str.encode())
+        digest.update(repr(array.shape).encode())
+        digest.update(array.tobytes(order="C"))
+
+    visit(tree)
+    return digest.hexdigest()
+
+
+def contains_restriction_map(tree: Any) -> bool:
+    if isinstance(tree, Mapping):
+        return any(
+            key in {"rm", "restriction_maps", "R_indices"} or contains_restriction_map(value)
+            for key, value in tree.items()
+        )
+    if isinstance(tree, (list, tuple)):
+        return any(contains_restriction_map(value) for value in tree)
+    return False
+
+
+def assert_common_bit_identical(
+    learned_params: Any,
+    identity_params: Any,
+    learned_optimizer: Any,
+    identity_optimizer: Any,
+    learned_counters: Any,
+    identity_counters: Any,
+) -> None:
+    if contains_restriction_map(identity_params):
+        raise InterventionError("identity parameter tree contains a restriction-map leaf")
+    if contains_restriction_map(identity_optimizer):
+        raise InterventionError("identity optimizer tree contains a restriction-map leaf")
+    pairs = (
+        (without_restriction_map(learned_params), identity_params, "parameter"),
+        (without_restriction_map(learned_optimizer), identity_optimizer, "optimizer"),
+        (learned_counters, identity_counters, "counter"),
+    )
+    for learned, identity, name in pairs:
+        if stable_tree_digest(learned) != stable_tree_digest(identity):
+            raise InterventionError(f"common {name} leaves are not bit-identical")
diff --git a/src/repro_control/launcher.py b/src/repro_control/launcher.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5bee400d7a3dfe2522b3380fbbe025722999af9
--- /dev/null
+++ b/src/repro_control/launcher.py
@@ -0,0 +1,432 @@
+"""Durable direct-launch state machine with submission disabled by default."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta, timezone
+from decimal import Decimal, ROUND_CEILING
+from pathlib import Path
+from typing import Any, Protocol
+
+from .constants import (
+    DEADLINE_UTC,
+    GPU_RETRY_RESERVE_MICRO_USD,
+    MAX_CPU_RETURNED_IDS,
+    MAX_GPU_RETURNED_IDS,
+    MAX_RETURNED_IDS,
+    MINIMUM_BALANCE_MICRO_USD,
+    NORMAL_CAP_MICRO_USD,
+)
+from .hashing import atomic_write_json
+from .manifests import REQUIRED_FIELDS, validate_manifest
+
+ACTIVE = frozenset({"PENDING_SUBMISSION", "SUBMITTED", "STARTING", "RUNNING", "CANCELING"})
+TERMINAL = frozenset({"COMPLETED", "FAILED", "CANCELED"})
+
+
+class LaunchError(RuntimeError):
+    pass
+
+
+class AmbiguousSubmission(LaunchError):
+    pass
+
+
+class Provider(Protocol):
+    def submit(self, request: dict[str, Any]) -> dict[str, Any]: ...
+
+    def find_by_label(self, label: str) -> list[dict[str, Any]]: ...
+
+    def get(self, job_id: str) -> dict[str, Any]: ...
+
+    def cancel(self, job_id: str) -> None: ...
+
+
+def parse_utc(value: str) -> datetime:
+    parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    if parsed.tzinfo is None:
+        raise ValueError("timestamp must include a timezone")
+    return parsed.astimezone(timezone.utc)
+
+
+def quantum_cost(rate_micro_usd_per_hour: int, seconds: int) -> int:
+    if rate_micro_usd_per_hour < 0 or seconds < 0:
+        raise ValueError("cost inputs must be nonnegative")
+    minutes = (seconds + 59) // 60
+    return (rate_micro_usd_per_hour * minutes + 59) // 60
+
+
+def rate_to_micro_usd(rate: str) -> int:
+    value = (Decimal(rate) * Decimal(1_000_000)).to_integral_value(rounding=ROUND_CEILING)
+    return int(value)
+
+
+def deterministic_attempt_id(
+    logical_id: str, ordinal: int, science_spec_sha256: str, science_freeze_sha256: str
+) -> str:
+    material = f"{logical_id}\0{ordinal}\0{science_spec_sha256}\0{science_freeze_sha256}"
+    return f"a{ordinal:02d}-{hashlib.sha256(material.encode()).hexdigest()[:20]}"
+
+
+def deterministic_label(logical_id: str, attempt_id: str) -> str:
+    return f"repro-{logical_id.lower()}-{attempt_id}"
+
+
+@dataclass(frozen=True)
+class BudgetSnapshot:
+    verified_balance_micro_usd: int
+    unsettled_estimate_micro_usd: int
+    incurred_micro_usd: int
+    active_remaining_micro_usd: int
+    mandatory_unsubmitted_micro_usd: int
+    non_job_cost_micro_usd: int = 0
+    gpu_retry_reserve_micro_usd: int = GPU_RETRY_RESERVE_MICRO_USD
+    cpu_retry_reserve_micro_usd: int = 0
+
+    def prospective_commitment(self, proposed_micro_usd: int) -> int:
+        return (
+            self.incurred_micro_usd
+            + self.active_remaining_micro_usd
+            + proposed_micro_usd
+            + self.mandatory_unsubmitted_micro_usd
+            + self.non_job_cost_micro_usd
+            + self.gpu_retry_reserve_micro_usd
+            + self.cpu_retry_reserve_micro_usd
+        )
+
+    def assert_feasible(self, proposed_micro_usd: int) -> None:
+        commitment = self.prospective_commitment(proposed_micro_usd)
+        if commitment > NORMAL_CAP_MICRO_USD:
+            raise LaunchError(f"normal spend cap exceeded: {commitment}>{NORMAL_CAP_MICRO_USD}")
+        available_after = (
+            self.verified_balance_micro_usd
+            - self.unsettled_estimate_micro_usd
+            - (commitment - self.incurred_micro_usd)
+        )
+        if available_after < MINIMUM_BALANCE_MICRO_USD:
+            raise LaunchError(
+                f"minimum balance gate failed: {available_after}<{MINIMUM_BALANCE_MICRO_USD}"
+            )
+
+
+@dataclass
+class LauncherState:
+    format: int = 1
+    attempts: list[dict[str, Any]] = field(default_factory=list)
+    reservations: list[dict[str, Any]] = field(default_factory=list)
+
+    @classmethod
+    def load(cls, path: Path) -> "LauncherState":
+        if not path.exists():
+            return cls()
+        value = json.loads(path.read_text())
+        if set(value) != {"format", "attempts", "reservations"} or value["format"] != 1:
+            raise LaunchError("invalid launcher state")
+        return cls(**value)
+
+    def save(self, path: Path) -> None:
+        atomic_write_json(
+            path,
+            {"format": self.format, "attempts": self.attempts, "reservations": self.reservations},
+        )
+
+    def returned_counts(self) -> tuple[int, int, int]:
+        returned = [row for row in self.attempts if row.get("job_id")]
+        gpu = sum(row.get("resource_class") == "GPU" for row in returned)
+        cpu = sum(row.get("resource_class") == "CPU" for row in returned)
+        return len(returned), gpu, cpu
+
+    def assert_identity_available(self, logical_id: str) -> None:
+        duplicate = [
+            row
+            for row in self.attempts
+            if row["logical_id"] == logical_id
+            and (row["state"] in ACTIVE or row["state"] == "COMPLETED")
+        ]
+        if duplicate:
+            raise LaunchError(f"duplicate active/complete logical identity {logical_id}")
+
+    def assert_id_capacity(self, resource_class: str) -> None:
+        total, gpu, cpu = self.returned_counts()
+        provisional = sum(row.get("provisional_id_slot", False) for row in self.attempts)
+        if total + provisional + 1 > MAX_RETURNED_IDS:
+            raise LaunchError("absolute returned-ID gate failed")
+        if resource_class == "GPU" and gpu + provisional + 1 > MAX_GPU_RETURNED_IDS:
+            raise LaunchError("GPU returned-ID gate failed")
+        if resource_class == "CPU" and cpu + provisional + 1 > MAX_CPU_RETURNED_IDS:
+            raise LaunchError("CPU returned-ID gate failed")
+
+
+class DirectLauncher:
+    """Provider-neutral launcher.
+
+    A real provider must be injected and ``enable_submit`` must be explicit.
+    The CLI never enables this in the local implementation turn.
+    """
+
+    def __init__(
+        self,
+        state_path: Path,
+        *,
+        provider: Provider | None = None,
+        enable_submit: bool = False,
+        deadline_utc: str = DEADLINE_UTC,
+        enforce_admission_sequence: bool = True,
+    ):
+        self.state_path = state_path
+        self.provider = provider
+        self.enable_submit = enable_submit
+        self.deadline = parse_utc(deadline_utc)
+        self.enforce_admission_sequence = enforce_admission_sequence
+
+    def assert_deadline(
+        self, now: datetime, guarded_critical_path_seconds: int, *, safety_hours: int = 12
+    ) -> None:
+        if now.tzinfo is None:
+            raise LaunchError("now must be timezone-aware")
+        finish = now.astimezone(timezone.utc) + timedelta(seconds=guarded_critical_path_seconds)
+        if finish > self.deadline - timedelta(hours=safety_hours):
+            raise LaunchError("guarded critical path misses the deadline safety margin")
+
+    def prepare(
+        self,
+        request: dict[str, Any],
+        *,
+        budget: BudgetSnapshot,
+        now: datetime,
+        guarded_critical_path_seconds: int,
+    ) -> dict[str, Any]:
+        state = LauncherState.load(self.state_path)
+        logical_id = request["logical_id"]
+        resource_class = request["resource_class"]
+        if self.enforce_admission_sequence:
+            canaries = [row for row in state.attempts if row["logical_id"] == "HF-CPU-CANARY"]
+            if not canaries and logical_id != "HF-CPU-CANARY":
+                raise LaunchError("the first attempted external mutation must be HF-CPU-CANARY")
+            if logical_id != "HF-CPU-CANARY" and not any(
+                row["state"] == "COMPLETED" for row in canaries
+            ):
+                raise LaunchError("CPU canary has not completed")
+        if request.get("is_retry"):
+            reason = request.get("retry_reason_class")
+            if reason != "INFRASTRUCTURE":
+                raise LaunchError("only classified infrastructure failures authorize retry")
+            prior_retries = sum(
+                row["resource_class"] == resource_class and row["request"].get("is_retry")
+                for row in state.attempts
+            )
+            ceiling = 3 if resource_class == "GPU" else 1
+            if prior_retries >= ceiling:
+                raise LaunchError(f"{resource_class} retry ceiling exhausted")
+        state.assert_identity_available(logical_id)
+        state.assert_id_capacity(resource_class)
+        self.assert_deadline(now, guarded_critical_path_seconds)
+        proposed = quantum_cost(
+            request["frozen_hourly_rate_micro_usd"], request["timeout_seconds"]
+        )
+        budget.assert_feasible(proposed)
+        ordinal = 1 + sum(row["logical_id"] == logical_id for row in state.attempts)
+        attempt_id = deterministic_attempt_id(
+            logical_id,
+            ordinal,
+            request["science_spec_sha256"],
+            request["science_freeze_sha256"],
+        )
+        if request.get("attempt_id") != attempt_id:
+            raise LaunchError(
+                f"request attempt_id mismatch: {request.get('attempt_id')!r}!={attempt_id!r}"
+            )
+        try:
+            manifest = {name: request[name] for name in REQUIRED_FIELDS}
+        except KeyError as exc:
+            raise LaunchError(f"request is missing manifest field {exc.args[0]!r}") from exc
+        try:
+            validate_manifest(
+                manifest,
+                freeze_sha256=(
+                    request["science_freeze_sha256"]
+                    if request["job_class"].startswith("SCIENTIFIC")
+                    else ""
+                ),
+            )
+        except ValueError as exc:
+            raise LaunchError(f"invalid Job manifest: {exc}") from exc
+        if request.get("hardware") != request.get("flavor"):
+            raise LaunchError("manifest hardware must equal provider flavor")
+        image = request.get("image")
+        if not isinstance(image, str) or not image.endswith(f"@{request['image_digest']}"):
+            raise LaunchError("provider image must end in the manifest image digest")
+        expected_resource_class = "CPU" if request["job_class"].startswith("CPU_") else "GPU"
+        if resource_class != expected_resource_class:
+            raise LaunchError(
+                f"{request['job_class']} requires resource_class={expected_resource_class}"
+            )
+        row = {
+            "logical_id": logical_id,
+            "attempt_id": attempt_id,
+            "label": deterministic_label(logical_id, attempt_id),
+            "resource_class": resource_class,
+            "state": "PENDING_SUBMISSION",
+            "job_id": "",
+            "job_url": "",
+            "provisional_id_slot": True,
+            "request": request,
+            "terminal_duration_seconds": None,
+            "estimated_cost_micro_usd": None,
+            "ready_at": "",
+            "last_heartbeat_at": "",
+        }
+        state.attempts.append(row)
+        state.reservations.append(
+            {
+                "attempt_id": attempt_id,
+                "reserved_timeout_cost_micro_usd": proposed,
+                "released": False,
+                "release_reason": "",
+            }
+        )
+        state.save(self.state_path)
+        return row
+
+    def submit_prepared(self, attempt_id: str) -> dict[str, Any]:
+        if not self.enable_submit:
+            raise LaunchError("submission disabled; inject a provider and explicitly enable it")
+        if self.provider is None:
+            raise LaunchError("no provider injected")
+        state = LauncherState.load(self.state_path)
+        row = _one(state, attempt_id)
+        if row["state"] != "PENDING_SUBMISSION":
+            raise LaunchError("attempt is not pending submission")
+        try:
+            result = self.provider.submit({**row["request"], "label": row["label"]})
+        except AmbiguousSubmission:
+            state.save(self.state_path)
+            raise
+        self._record_submit_result(state, row, result)
+        state.save(self.state_path)
+        return row
+
+    def reconcile_ambiguous(self, attempt_id: str) -> dict[str, Any]:
+        if self.provider is None:
+            raise LaunchError("no provider injected")
+        state = LauncherState.load(self.state_path)
+        row = _one(state, attempt_id)
+        if row["state"] != "PENDING_SUBMISSION":
+            raise LaunchError("only pending submissions can be reconciled")
+        matches = self.provider.find_by_label(row["label"])
+        if len(matches) > 1:
+            raise LaunchError("duplicate provider labels; owner review required")
+        if len(matches) == 1:
+            self._record_submit_result(state, row, matches[0])
+        else:
+            row["provisional_id_slot"] = False
+            row["state"] = "ABSENT_AFTER_RECONCILIATION"
+            _release_reservation(state, attempt_id, "provider_absence_proved")
+        state.save(self.state_path)
+        return row
+
+    @staticmethod
+    def _record_submit_result(
+        state: LauncherState, row: dict[str, Any], result: dict[str, Any]
+    ) -> None:
+        job_id, job_url = result.get("job_id"), result.get("job_url")
+        if not job_id or not job_url:
+            raise AmbiguousSubmission("provider response did not contain a complete identity")
+        if any(other.get("job_id") == job_id for other in state.attempts if other is not row):
+            raise LaunchError("provider job ID is already recorded")
+        row.update(
+            state="SUBMITTED",
+            job_id=job_id,
+            job_url=job_url,
+            provisional_id_slot=False,
+        )
+
+    def poll(self, attempt_id: str, *, now: datetime) -> dict[str, Any]:
+        if self.provider is None:
+            raise LaunchError("no provider injected")
+        state = LauncherState.load(self.state_path)
+        row = _one(state, attempt_id)
+        if not row["job_id"]:
+            raise LaunchError("attempt has no provider job ID")
+        remote = self.provider.get(row["job_id"])
+        remote_state = remote["state"]
+        if remote_state not in ACTIVE | TERMINAL:
+            raise LaunchError(f"unknown provider lifecycle state {remote_state!r}")
+        row["state"] = remote_state
+        if remote.get("ready_marker"):
+            row["ready_at"] = remote.get("ready_at") or now.astimezone(timezone.utc).isoformat()
+        if remote.get("heartbeat"):
+            row["last_heartbeat_at"] = remote.get("heartbeat_at") or now.astimezone(
+                timezone.utc
+            ).isoformat()
+        self._enforce_runtime_gates(row, remote, now)
+        if remote_state in TERMINAL:
+            duration = remote.get("billable_duration_seconds")
+            if not isinstance(duration, int) or duration < 0:
+                raise LaunchError("terminal attempt lacks final billable duration")
+            row["terminal_duration_seconds"] = duration
+            row["estimated_cost_micro_usd"] = quantum_cost(
+                row["request"]["frozen_hourly_rate_micro_usd"], duration
+            )
+            _release_reservation(state, attempt_id, "terminal_duration_recorded")
+        state.save(self.state_path)
+        return row
+
+    @staticmethod
+    def _enforce_runtime_gates(
+        row: dict[str, Any], remote: dict[str, Any], now: datetime
+    ) -> None:
+        billable_start = next(
+            (
+                remote.get(name)
+                for name in ("starting_at", "started_at", "first_running_at")
+                if remote.get(name)
+            ),
+            None,
+        )
+        if not billable_start or row["state"] in TERMINAL:
+            return
+        elapsed = (now.astimezone(timezone.utc) - parse_utc(billable_start)).total_seconds()
+        if not row["ready_at"] and elapsed > 180:
+            raise LaunchError("readiness deadline exceeded")
+        heartbeat_deadline = (
+            (
+                max(
+                    180,
+                    3 * row["request"]["largest_guarded_no_output_block_seconds"],
+                )
+                + 59
+            )
+            // 60
+        ) * 60
+        heartbeat_from = parse_utc(row["last_heartbeat_at"] or billable_start)
+        if (now.astimezone(timezone.utc) - heartbeat_from).total_seconds() > heartbeat_deadline:
+            raise LaunchError("heartbeat deadline exceeded")
+
+    def cancel(self, attempt_id: str) -> None:
+        if not self.enable_submit or self.provider is None:
+            raise LaunchError("cancellation disabled without an explicitly enabled provider")
+        state = LauncherState.load(self.state_path)
+        row = _one(state, attempt_id)
+        if row["state"] not in ACTIVE or not row["job_id"]:
+            raise LaunchError("attempt is not cancelable")
+        self.provider.cancel(row["job_id"])
+        row["state"] = "CANCELING"
+        state.save(self.state_path)
+
+
+def _one(state: LauncherState, attempt_id: str) -> dict[str, Any]:
+    matches = [row for row in state.attempts if row["attempt_id"] == attempt_id]
+    if len(matches) != 1:
+        raise LaunchError(f"attempt lookup returned {len(matches)} rows")
+    return matches[0]
+
+
+def _release_reservation(state: LauncherState, attempt_id: str, reason: str) -> None:
+    matches = [row for row in state.reservations if row["attempt_id"] == attempt_id]
+    if len(matches) != 1:
+        raise LaunchError("attempt reservation is missing or duplicated")
+    matches[0]["released"] = True
+    matches[0]["release_reason"] = reason
diff --git a/src/repro_control/manifests.py b/src/repro_control/manifests.py
new file mode 100644
index 0000000000000000000000000000000000000000..7faf3caab204c7dc7264ba3dd0a026517f689e99
--- /dev/null
+++ b/src/repro_control/manifests.py
@@ -0,0 +1,152 @@
+"""Strict static and lifecycle-aware Job manifest validation."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import PurePosixPath
+from typing import Any
+
+from .constants import NOT_APPLICABLE, SCIENCE_SPEC_SHA256
+
+JOB_CLASSES = frozenset(
+    {"CPU_CANARY", "CPU_IMPORT", "GPU_SMOKE", "SCIENTIFIC_TRAIN", "SCIENTIFIC_EVAL"}
+)
+REQUIRED_FIELDS = frozenset(
+    {
+        "job_class",
+        "logical_id",
+        "attempt_id",
+        "image_digest",
+        "science_spec_sha256",
+        "science_freeze_sha256",
+        "hashes",
+        "task",
+        "seed",
+        "intervention",
+        "hardware",
+        "frozen_hourly_rate_micro_usd",
+        "timeout_seconds",
+        "largest_guarded_no_output_block_seconds",
+        "command",
+        "expected_outputs",
+        "mounts",
+    }
+)
+SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
+ID_RE = re.compile(r"^[A-Z0-9][A-Z0-9-]{1,95}$")
+ATTEMPT_RE = re.compile(r"^[a-z0-9][a-z0-9-]{7,95}$")
+
+
+class ManifestError(ValueError):
+    pass
+
+
+def _exact_keys(value: dict[str, Any], expected: frozenset[str], where: str) -> None:
+    missing = expected - value.keys()
+    extra = value.keys() - expected
+    if missing or extra:
+        raise ManifestError(f"{where} keys: missing={sorted(missing)}, extra={sorted(extra)}")
+
+
+def _sha_or_empty(value: Any, name: str) -> None:
+    if value != "" and (not isinstance(value, str) or not SHA256_RE.fullmatch(value)):
+        raise ManifestError(f"{name} must be empty or lowercase SHA-256")
+
+
+def validate_mount(mount: dict[str, Any]) -> None:
+    _exact_keys(
+        mount,
+        frozenset({"volume_source", "volume_path", "mount_path", "read_only"}),
+        "mount",
+    )
+    for name in ("volume_source", "volume_path", "mount_path"):
+        if not isinstance(mount[name], str) or not mount[name]:
+            raise ManifestError(f"mount {name} must be a non-empty string")
+    path = PurePosixPath(mount["mount_path"])
+    if not path.is_absolute() or ".." in path.parts:
+        raise ManifestError("mount_path must be normalized and absolute")
+    if not isinstance(mount["read_only"], bool):
+        raise ManifestError("mount read_only must be boolean")
+
+
+def validate_manifest(value: dict[str, Any], *, freeze_sha256: str = "") -> None:
+    _exact_keys(value, REQUIRED_FIELDS, "manifest")
+    job_class = value["job_class"]
+    if job_class not in JOB_CLASSES:
+        raise ManifestError(f"unknown job_class {job_class!r}")
+    if not isinstance(value["logical_id"], str) or not ID_RE.fullmatch(value["logical_id"]):
+        raise ManifestError("logical_id must be a neutral uppercase identity")
+    if not isinstance(value["attempt_id"], str) or not ATTEMPT_RE.fullmatch(value["attempt_id"]):
+        raise ManifestError("attempt_id must be a deterministic lowercase identity")
+    if not isinstance(value["image_digest"], str) or not (
+        value["image_digest"].startswith("sha256:") and SHA256_RE.fullmatch(value["image_digest"][7:])
+    ):
+        raise ManifestError("image_digest must be sha256:<digest>")
+    expected_spec = NOT_APPLICABLE if job_class == "CPU_CANARY" else SCIENCE_SPEC_SHA256
+    if value["science_spec_sha256"] != expected_spec:
+        raise ManifestError(f"{job_class} science_spec_sha256 must be {expected_spec}")
+    if job_class in {"SCIENTIFIC_TRAIN", "SCIENTIFIC_EVAL"}:
+        if not freeze_sha256 or not SHA256_RE.fullmatch(freeze_sha256):
+            raise ManifestError("scientific manifest requires the expected freeze SHA-256")
+        if value["science_freeze_sha256"] != freeze_sha256:
+            raise ManifestError("scientific manifest freeze mismatch")
+    elif value["science_freeze_sha256"] != NOT_APPLICABLE:
+        raise ManifestError(f"{job_class} science_freeze_sha256 must be NOT_APPLICABLE")
+    if not isinstance(value["hashes"], dict):
+        raise ManifestError("hashes must be an object")
+    for name in ("source", "config", "data", "checkpoint"):
+        if name not in value["hashes"]:
+            raise ManifestError(f"hashes missing {name}")
+        _sha_or_empty(value["hashes"][name], f"hashes.{name}")
+    if value["seed"] not in (None, 42, 123, 456):
+        raise ManifestError("seed must be null or registered")
+    if not isinstance(value["frozen_hourly_rate_micro_usd"], int) or value[
+        "frozen_hourly_rate_micro_usd"
+    ] < 0:
+        raise ManifestError("rate must be a nonnegative integer")
+    for name in ("timeout_seconds", "largest_guarded_no_output_block_seconds"):
+        if not isinstance(value[name], int) or value[name] <= 0:
+            raise ManifestError(f"{name} must be a positive integer")
+    if not isinstance(value["command"], list) or not value["command"] or not all(
+        isinstance(item, str) and item for item in value["command"]
+    ):
+        raise ManifestError("command must be a non-empty argv list")
+    if not isinstance(value["expected_outputs"], list) or not value["expected_outputs"]:
+        raise ManifestError("expected_outputs must be a non-empty list")
+    if "DONE.json" not in value["expected_outputs"]:
+        raise ManifestError("expected_outputs must include DONE.json")
+    if not isinstance(value["mounts"], list):
+        raise ManifestError("mounts must be a list")
+    for mount in value["mounts"]:
+        validate_mount(mount)
+    if job_class in {"SCIENTIFIC_TRAIN", "SCIENTIFIC_EVAL"}:
+        controls = [m for m in value["mounts"] if m["mount_path"] == "/repro-control"]
+        if len(controls) != 1 or not controls[0]["read_only"]:
+            raise ManifestError("scientific jobs require one read-only /repro-control mount")
+
+
+def validate_prefix_capability(
+    requested_path: str, allowed_prefix: str, *, write: bool, read_only: bool
+) -> None:
+    requested = PurePosixPath("/" + requested_path.lstrip("/"))
+    allowed = PurePosixPath("/" + allowed_prefix.lstrip("/"))
+    if ".." in PurePosixPath(requested_path).parts:
+        raise ManifestError("parent traversal forbidden")
+    try:
+        requested.relative_to(allowed)
+    except ValueError as exc:
+        raise ManifestError("requested object lies outside the mounted prefix") from exc
+    if write and read_only:
+        raise ManifestError("write forbidden by read-only capability")
+
+
+@dataclass(frozen=True)
+class ReadinessContract:
+    ready_deadline_seconds: int = 180
+    heartbeat_interval_seconds: int = 60
+
+    @staticmethod
+    def heartbeat_deadline(largest_guarded_no_output_block_seconds: int) -> int:
+        raw = max(180, 3 * largest_guarded_no_output_block_seconds)
+        return ((raw + 59) // 60) * 60
diff --git a/src/repro_control/privacy.py b/src/repro_control/privacy.py
new file mode 100644
index 0000000000000000000000000000000000000000..f483c8937138bfdd72924fc11598d00d228670c1
--- /dev/null
+++ b/src/repro_control/privacy.py
@@ -0,0 +1,95 @@
+"""Deterministic public-byte inventory and conservative privacy scanner."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+from .hashing import atomic_write_json, canonical_root, file_entry
+
+SCANNER_VERSION = "repro-privacy-1"
+EXCLUDED_LOCAL_PARTS = frozenset({".git", ".venv", ".uv-cache", "__pycache__"})
+RULES = {
+    "credential_assignment": re.compile(
+        rb"(?i)(?:hf_token|huggingface_token|api[_-]?key|authorization)\\s*[:=]\\s*[\"']?[A-Za-z0-9_-]{12,}"
+    ),
+    "hf_token_shape": re.compile(rb"hf_[A-Za-z0-9]{20,}"),
+    "private_key": re.compile(rb"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----"),
+    "home_path": re.compile(rb"/(?:Users|home)/[A-Za-z0-9._-]+/"),
+    "private_phase_program": re.compile(
+        rb"(?i)(?:ph" rb"ase[\s_-]*1|sheaf-p" rb"11|p1\.[0-9])"
+    ),
+    "private_phase0_run_id": re.compile(
+        rb"\bE-(?:mnist|maze|sudoku)-s(?:42|123|456)(?:-[A-Za-z0-9_-]+)?\b"
+    ),
+}
+
+
+class PrivacyError(ValueError):
+    pass
+
+
+def scan_paths(
+    roots: Iterable[Path],
+    *,
+    relative_to: Path,
+    intended_remote_map: dict[str, str],
+    allow_checkpoint_references: frozenset[str] = frozenset(),
+) -> dict[str, Any]:
+    relative_to = relative_to.resolve()
+    paths: list[Path] = []
+    for root in roots:
+        root = root.resolve()
+        if root.is_file():
+            paths.append(root)
+        elif root.is_dir():
+            paths.extend(
+                path
+                for path in root.rglob("*")
+                if path.is_file()
+                and not (set(path.relative_to(relative_to).parts) & EXCLUDED_LOCAL_PARTS)
+            )
+    unique = sorted(set(paths))
+    entries, findings = [], []
+    for path in unique:
+        entry = file_entry(path, relative_to=relative_to)
+        entries.append(entry)
+        data = path.read_bytes()
+        display = entry["path"]
+        if display.endswith((".pkl", ".pickle")) and display not in allow_checkpoint_references:
+            findings.append(
+                {
+                    "path": display,
+                    "rule": "checkpoint_bytes",
+                    "offset": 0,
+                    "match_sha256": entry["sha256"],
+                }
+            )
+        for rule, pattern in RULES.items():
+            for match in pattern.finditer(data):
+                findings.append(
+                    {
+                        "path": display,
+                        "rule": rule,
+                        "offset": match.start(),
+                        "match_sha256": __import__("hashlib").sha256(match.group()).hexdigest(),
+                    }
+                )
+    return {
+        "format": 1,
+        "scanner_version": SCANNER_VERSION,
+        "rules": sorted(RULES),
+        "files": entries,
+        "root_sha256": canonical_root(entries),
+        "findings": findings,
+        "intended_remote_map": intended_remote_map,
+        "exit_code": 1 if findings else 0,
+    }
+
+
+def write_receipt(path: Path, receipt: dict[str, Any], *, require_clean: bool = True) -> None:
+    atomic_write_json(path, receipt)
+    if require_clean and receipt["exit_code"] != 0:
+        raise PrivacyError(f"privacy scanner found {len(receipt['findings'])} findings")
diff --git a/src/repro_control/reducers.py b/src/repro_control/reducers.py
new file mode 100644
index 0000000000000000000000000000000000000000..34e2abd95be4ef5def761ae1f4413c414a45526f
--- /dev/null
+++ b/src/repro_control/reducers.py
@@ -0,0 +1,179 @@
+"""Exhaustive registered reducers; callers must supply accepted complete seeds."""
+
+from __future__ import annotations
+
+import math
+import statistics
+from dataclasses import dataclass
+from typing import Iterable
+
+T95_DF2 = 4.302652729911275
+T90_DF2 = 2.919985580355516
+
+
+class ReducerInputError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class Summary:
+    seeds: tuple[float, float, float]
+    mean: float
+    sample_std: float
+    lower: float
+    upper: float
+    confidence: int
+
+
+def _three(values: Iterable[float], name: str) -> tuple[float, float, float]:
+    row = tuple(float(value) for value in values)
+    if len(row) != 3 or not all(math.isfinite(value) for value in row):
+        raise ReducerInputError(f"{name} must contain three finite accepted-seed values")
+    return row  # type: ignore[return-value]
+
+
+def summarize(values: Iterable[float], confidence: int = 95) -> Summary:
+    row = _three(values, "values")
+    critical = {95: T95_DF2, 90: T90_DF2}.get(confidence)
+    if critical is None:
+        raise ReducerInputError("confidence must be 90 or 95")
+    mean = statistics.fmean(row)
+    sample_std = statistics.stdev(row)
+    half = critical * sample_std / math.sqrt(3)
+    return Summary(row, mean, sample_std, mean - half, mean + half, confidence)
+
+
+def paired(left: Iterable[float], right: Iterable[float], confidence: int = 95) -> Summary:
+    left_row, right_row = _three(left, "left"), _three(right, "right")
+    return summarize((a - b for a, b in zip(left_row, right_row, strict=True)), confidence)
+
+
+def reduce_c1(
+    sheaf: Iterable[float],
+    mpnn: Iterable[float],
+    *,
+    sheaf_parameters: int,
+    mpnn_parameters: int,
+) -> dict:
+    s, m, gap = summarize(sheaf), summarize(mpnn), paired(sheaf, mpnn)
+    mismatch = abs(mpnn_parameters - sheaf_parameters) / sheaf_parameters
+    parameter = (
+        "PARAMETER_MATCH_REPRODUCED"
+        if mismatch <= 0.05
+        else "RELEASED_IMPLEMENTATION_NOT_PARAMETER_MATCHED"
+    )
+    if s.mean >= 85 and m.mean <= 20 and gap.lower > 60:
+        functional = "FUNCTIONAL_GAP_REPRODUCED"
+    elif s.mean < 85 or m.mean > 20 or gap.upper <= 60:
+        functional = "NOT_REPRODUCED_UNDER_PAPER_ROW_RECONSTRUCTION"
+    else:
+        functional = "INCONCLUSIVE"
+    overall = (
+        "FUNCTIONAL_GAP_REPRODUCED_BUT_RELEASE_NOT_PARAMETER_MATCHED"
+        if functional == "FUNCTIONAL_GAP_REPRODUCED"
+        and parameter == "RELEASED_IMPLEMENTATION_NOT_PARAMETER_MATCHED"
+        else functional
+    )
+    return {
+        "functional": functional,
+        "parameter": parameter,
+        "overall": overall,
+        "relative_count_mismatch": mismatch,
+        "summaries": {"sheaf": s, "mpnn": m, "paired_gap": gap},
+    }
+
+
+def reduce_c2(sheaf: Iterable[float], mpnn: Iterable[float]) -> dict:
+    s, m, gap = summarize(sheaf), summarize(mpnn), paired(sheaf, mpnn, 90)
+    if s.mean >= 95 and m.mean >= 95 and gap.lower >= -2 and gap.upper <= 2:
+        verdict = "STATE_EFFICIENCY_REPRODUCED"
+    elif s.mean < 90 or m.mean < 90 or gap.lower > 2 or gap.upper < -2:
+        verdict = "NOT_REPRODUCED"
+    else:
+        verdict = "INCONCLUSIVE"
+    return {
+        "verdict": verdict,
+        "per_vertex_latent_dimension_ratio": 8.4,
+        "memory_reduction_claimed": False,
+        "summaries": {"sheaf": s, "mpnn": m, "paired_gap_90": gap},
+    }
+
+
+def _adequate(values: tuple[float, float, float]) -> bool:
+    return statistics.fmean(values) >= 98.5 and min(values) >= 98.0
+
+
+def reduce_c3(
+    cnn_clean: Iterable[float],
+    sheaf_clean: Iterable[float],
+    cnn_pad16: Iterable[float],
+    sheaf_pad16: Iterable[float],
+    cnn_drop30: Iterable[float],
+    sheaf_drop30: Iterable[float],
+) -> dict:
+    cnn_clean_row = _three(cnn_clean, "cnn_clean")
+    sheaf_clean_row = _three(sheaf_clean, "sheaf_clean")
+    cnn_ok, sheaf_ok = _adequate(cnn_clean_row), _adequate(sheaf_clean_row)
+    if not cnn_ok or not sheaf_ok:
+        who = "BOTH" if not cnn_ok and not sheaf_ok else ("CNN" if not cnn_ok else "SHEAF")
+        verdict = f"INCONCLUSIVE_{who}_CLEAN_REFERENCE_INADEQUATE"
+        pad_gap = drop_gap = None
+    else:
+        pad_gap = paired(sheaf_pad16, cnn_pad16)
+        drop_gap = paired(sheaf_drop30, cnn_drop30)
+        if pad_gap.lower > 20 and drop_gap.lower > 10:
+            verdict = "ROBUSTNESS_GAPS_REPRODUCED"
+        elif pad_gap.upper <= 20 or drop_gap.upper <= 10:
+            verdict = "NOT_REPRODUCED_UNDER_TIER_B_RECONSTRUCTION"
+        else:
+            verdict = "INCONCLUSIVE"
+    return {
+        "verdict": f"{verdict}__DROPOUT_SEMANTICS_TARGET_SELECTED",
+        "clean_adequacy": {"cnn": cnn_ok, "sheaf": sheaf_ok},
+        "paired_gaps": {"pad16": pad_gap, "drop30": drop_gap},
+    }
+
+
+def reduce_c4_sudoku(learned: Iterable[float], identity: Iterable[float]) -> dict:
+    learned_summary, identity_summary = summarize(learned), summarize(identity)
+    gap = paired(learned, identity)
+    if learned_summary.mean >= 85 and identity_summary.mean <= 15 and gap.lower > 60:
+        verdict = "IDENTITY_ABLATION_REPRODUCED"
+    elif learned_summary.mean < 85 or identity_summary.mean > 15 or gap.upper <= 60:
+        verdict = "NOT_REPRODUCED"
+    else:
+        verdict = "INCONCLUSIVE"
+    return {"verdict": verdict, "learned": learned_summary, "identity": identity_summary, "gap": gap}
+
+
+def reduce_c4_maze(default: Iterable[float], quadratic: Iterable[float]) -> dict:
+    default_summary, quadratic_summary = summarize(default), summarize(quadratic)
+    gap = paired(default, quadratic)
+    if default_summary.mean >= 90 and quadratic_summary.mean >= 90 and gap.upper < 20:
+        verdict = "SUPPLIED_COLLAPSE_WORDING_FALSIFIED"
+    elif default_summary.mean >= 90 and quadratic_summary.mean <= 60 and gap.lower > 20:
+        verdict = "DIRECTION_SUPPORTED_UNDER_RECONSTRUCTION"
+    else:
+        verdict = "INCONCLUSIVE"
+    return {
+        "verdict": f"{verdict}__PROMPT_MISSTATES_PAPER_TABLE",
+        "default": default_summary,
+        "quadratic": quadratic_summary,
+        "gap": gap,
+    }
+
+
+def reduce_c5(by_size: dict[int, Iterable[float]]) -> dict:
+    expected = {19, 23, 27, 31, 35, 39}
+    if set(by_size) != expected:
+        raise ReducerInputError("C5 requires all six registered sizes")
+    summaries = {size: summarize(by_size[size]) for size in sorted(by_size)}
+    if all(summary.mean >= 95 for summary in summaries.values()):
+        verdict = "QUALITATIVE_2X_GENERALIZATION_SUPPORTED_UNDER_REGISTERED_RECONSTRUCTION"
+    else:
+        verdict = "NOT_REPRODUCED_UNDER_REGISTERED_LONG_PATH_RECONSTRUCTION"
+    return {
+        "verdict": verdict,
+        "exact_protocol": "INCONCLUSIVE_EXACT_DENSE_FIGURE6_CONFIG_UNRELEASED",
+        "summaries": summaries,
+    }
diff --git a/src/repro_control/runtime.py b/src/repro_control/runtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..85ad2989476f177f68bed9e516e8f4cd304d2c7b
--- /dev/null
+++ b/src/repro_control/runtime.py
@@ -0,0 +1,93 @@
+"""Entrypoint guards shared by import, smoke, train, and evaluation."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+
+from .constants import SCIENCE_SPEC_SHA256
+from .manifests import validate_manifest
+
+
+class RuntimeContractError(RuntimeError):
+    pass
+
+
+def sha256_file(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def verify_science_spec(path: Path) -> dict:
+    if sha256_file(path) != SCIENCE_SPEC_SHA256:
+        raise RuntimeContractError("SCIENCE-SPEC.yaml hash mismatch")
+    value = json.loads(path.read_text())
+    if value.get("outcomes") != {}:
+        raise RuntimeContractError("science spec outcomes must remain empty")
+    return value
+
+
+def load_job_manifest(path: Path, *, freeze_sha256: str = "") -> dict:
+    value = json.loads(path.read_text())
+    validate_manifest(value, freeze_sha256=freeze_sha256)
+    return value
+
+
+def assert_smoke_isolated(manifest: dict) -> None:
+    if manifest["job_class"] != "GPU_SMOKE":
+        raise RuntimeContractError("smoke entrypoint requires GPU_SMOKE")
+    forbidden = ("final", "verdict", "test_hard", "test_ood", "evaluation")
+    for mount in manifest["mounts"]:
+        text = f"{mount['volume_path']} {mount['mount_path']}".lower()
+        if any(term in text for term in forbidden):
+            raise RuntimeContractError("smoke manifest exposes final/evaluation data")
+    for output in manifest["expected_outputs"]:
+        if "verdict" in output.lower():
+            raise RuntimeContractError("smoke entrypoint cannot emit verdict metrics")
+
+
+def assert_evaluation_isolated(manifest: dict) -> None:
+    if manifest["job_class"] != "SCIENTIFIC_EVAL":
+        raise RuntimeContractError("evaluation entrypoint requires SCIENTIFIC_EVAL")
+    for mount in manifest["mounts"]:
+        text = f"{mount['volume_path']} {mount['mount_path']}".lower()
+        if "train-data" in text or "/train" in text or text.endswith(" train"):
+            raise RuntimeContractError("evaluation manifest exposes registered training data")
+
+
+def require_control_freeze(
+    control_dir: Path, expected_freeze_sha256: str, expected_spec_sha256: str
+) -> dict:
+    freeze_path = control_dir / "SCIENCE-FREEZE.yaml"
+    if not freeze_path.is_file() or sha256_file(freeze_path) != expected_freeze_sha256:
+        raise RuntimeContractError("control freeze hash mismatch")
+    value = json.loads(freeze_path.read_text())
+    if value.get("science_spec_sha256") != expected_spec_sha256:
+        raise RuntimeContractError("freeze binds a different science spec")
+    return value
+
+
+def configure_scientific_runtime() -> None:
+    os.environ["JAX_DEFAULT_MATMUL_PRECISION"] = "highest"
+    os.environ.setdefault("TRACE_MODE", "none")
+
+
+def require_jax_platform(expected: str) -> str:
+    import jax
+
+    observed = jax.devices()[0].platform
+    if observed != expected:
+        raise RuntimeContractError(
+            f"scientific runtime requires JAX platform {expected!r}, observed {observed!r}"
+        )
+    return observed
+
+
+def common_parser(description: str) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument("--science-spec", type=Path, required=True)
+    parser.add_argument("--job-manifest", type=Path, required=True)
+    parser.add_argument("--dry-run", action="store_true", default=False)
+    return parser
diff --git a/src/repro_control/scaffold.py b/src/repro_control/scaffold.py
new file mode 100644
index 0000000000000000000000000000000000000000..d113dc8ac615f6c9ef455f4192607cb463395800
--- /dev/null
+++ b/src/repro_control/scaffold.py
@@ -0,0 +1,144 @@
+"""Exact in-place replacement of the two pinned Executive-summary cells."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from .hashing import atomic_write_bytes, atomic_write_json
+
+SUMMARY_PLACEHOLDER = "Write a 3–5 sentence outcome-first summary here."
+POSTER_PLACEHOLDER = "Build a reproduction poster"
+SUMMARY_TITLE = "Executive summary"
+POSTER_PLACEHOLDER_TITLE = "Reproduction poster (poster_embed.html)"
+POSTER_FINAL_TITLE = "Reproduction poster"
+
+_CELL_RE = re.compile(
+    r"(?ms)^---\n<!-- trackio-cell\n(?P<meta>\{.*?\})\n-->\n"
+    r"(?P<body>.*?)(?=^---\n<!-- trackio-cell\n|\Z)"
+)
+
+
+class ScaffoldError(ValueError):
+    pass
+
+
+def replace_cells(value: dict, *, summary_body: str, poster_html: str) -> dict:
+    pages = value.get("pages")
+    if not isinstance(pages, list):
+        raise ScaffoldError("scaffold export must contain pages")
+    executive = [page for page in pages if page.get("title") == "Executive summary"]
+    if len(executive) != 1:
+        raise ScaffoldError("expected exactly one Executive summary page")
+    cells = executive[0].get("cells")
+    if not isinstance(cells, list):
+        raise ScaffoldError("Executive summary cells missing")
+    pinned = [cell for cell in cells if cell.get("pinned") is True]
+    if len(pinned) != 2:
+        raise ScaffoldError("Executive summary must contain exactly two pinned cells")
+    if [cell.get("title") for cell in pinned] != [
+        SUMMARY_TITLE,
+        POSTER_PLACEHOLDER_TITLE,
+    ]:
+        raise ScaffoldError("pinned cell titles/order differ from the official scaffold")
+    if SUMMARY_PLACEHOLDER not in pinned[0].get("body", ""):
+        raise ScaffoldError("summary placeholder not found")
+    if POSTER_PLACEHOLDER not in pinned[1].get("body", ""):
+        raise ScaffoldError("poster placeholder not found")
+    original_ids = [cell.get("id") for cell in pinned]
+    pinned[0]["body"] = summary_body
+    pinned[1]["body"] = poster_html
+    pinned[1]["title"] = POSTER_FINAL_TITLE
+    if [cell.get("id") for cell in pinned] != original_ids:
+        raise ScaffoldError("cell identity changed")
+    serialized = json.dumps(value)
+    if SUMMARY_PLACEHOLDER in serialized or POSTER_PLACEHOLDER in serialized:
+        raise ScaffoldError("placeholder remains after replacement")
+    return value
+
+
+def _figure_body(html: str) -> str:
+    if "````" in html:
+        raise ScaffoldError("poster HTML cannot contain a four-backtick fence")
+    return f"````html\n{html.rstrip()}\n````\n"
+
+
+def replace_trackio_page(path: Path, *, summary_body: str, poster_html: str) -> None:
+    """Replace the real Trackio v2 markdown cells while preserving their IDs."""
+    text = path.read_text(encoding="utf-8")
+    matches = list(_CELL_RE.finditer(text))
+    if len(matches) != 2:
+        raise ScaffoldError("official Executive summary page must contain exactly two cells")
+    parsed = []
+    for match in matches:
+        try:
+            metadata = json.loads(match.group("meta"))
+        except json.JSONDecodeError as exc:
+            raise ScaffoldError("invalid Trackio cell metadata") from exc
+        parsed.append((match, metadata, match.group("body")))
+    if [meta.get("title") for _, meta, _ in parsed] != [
+        SUMMARY_TITLE,
+        POSTER_PLACEHOLDER_TITLE,
+    ]:
+        raise ScaffoldError("Trackio cell titles/order differ from the official scaffold")
+    if any(meta.get("pinned") is not True for _, meta, _ in parsed):
+        raise ScaffoldError("both official Executive summary cells must be pinned")
+    if len({meta.get("id") for _, meta, _ in parsed}) != 2 or any(
+        not meta.get("id") for _, meta, _ in parsed
+    ):
+        raise ScaffoldError("Trackio cell IDs are missing or duplicated")
+    if SUMMARY_PLACEHOLDER not in parsed[0][2]:
+        raise ScaffoldError("summary placeholder not found")
+    if POSTER_PLACEHOLDER not in parsed[1][2]:
+        raise ScaffoldError("poster placeholder not found")
+
+    replacement_bodies = [summary_body.rstrip() + "\n", _figure_body(poster_html)]
+    original_ids = [meta["id"] for _, meta, _ in parsed]
+    output = []
+    cursor = 0
+    for index, (match, metadata, _) in enumerate(parsed):
+        output.append(text[cursor : match.start()])
+        if index == 1:
+            metadata["title"] = POSTER_FINAL_TITLE
+        output.append("---\n<!-- trackio-cell\n")
+        output.append(json.dumps(metadata, ensure_ascii=False, separators=(",", ": ")))
+        output.append("\n-->\n")
+        output.append(replacement_bodies[index])
+        cursor = match.end()
+    output.append(text[cursor:])
+    rendered = "".join(output)
+    if SUMMARY_PLACEHOLDER in rendered or POSTER_PLACEHOLDER in rendered:
+        raise ScaffoldError("placeholder remains after Trackio replacement")
+    rewritten = list(_CELL_RE.finditer(rendered))
+    if len(rewritten) != 2:
+        raise ScaffoldError("replacement changed Trackio cell cardinality")
+    rewritten_meta = [json.loads(match.group("meta")) for match in rewritten]
+    if [meta["id"] for meta in rewritten_meta] != original_ids:
+        raise ScaffoldError("replacement changed Trackio cell identity")
+    if [meta.get("title") for meta in rewritten_meta] != [
+        SUMMARY_TITLE,
+        POSTER_FINAL_TITLE,
+    ]:
+        raise ScaffoldError("replacement did not set final cell titles")
+    atomic_write_bytes(path, rendered.encode("utf-8"))
+
+
+def replace_scaffold_file(
+    path: Path, *, summary_path: Path, poster_path: Path, output_path: Path | None = None
+) -> None:
+    summary_body = summary_path.read_text(encoding="utf-8")
+    poster_html = poster_path.read_text(encoding="utf-8")
+    if path.suffix.lower() in {".md", ".markdown"}:
+        if output_path is not None and output_path != path:
+            atomic_write_bytes(output_path, path.read_bytes())
+            path = output_path
+        replace_trackio_page(path, summary_body=summary_body, poster_html=poster_html)
+        return
+    value = json.loads(path.read_text(encoding="utf-8"))
+    replaced = replace_cells(
+        value,
+        summary_body=summary_body,
+        poster_html=poster_html,
+    )
+    atomic_write_json(output_path or path, replaced)
diff --git a/src/repro_control/smoke_runtime.py b/src/repro_control/smoke_runtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa6bbdff5dad005f373adb6640cc651720d7116e
--- /dev/null
+++ b/src/repro_control/smoke_runtime.py
@@ -0,0 +1,661 @@
+"""Real, verdict-isolated workload probes used by the three GPU admission Jobs."""
+
+from __future__ import annotations
+
+import json
+import os
+import pickle
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from .c5_runtime import Probe, select_batch
+from .configs import registered_config_for
+from .data import C5_SIZES, apply_patch_dropout, deterministic_lpt
+from .hashing import sha256_file
+from .interventions import assert_common_bit_identical
+
+
+class SmokeRuntimeError(RuntimeError):
+    pass
+
+
+def _repeat(array: np.ndarray, count: int) -> np.ndarray:
+    if len(array) == 0:
+        raise SmokeRuntimeError("fixture array is empty")
+    indices = np.arange(count) % len(array)
+    return np.asarray(array[indices])
+
+
+def _jax_peak_bytes() -> int | None:
+    import jax
+
+    stats = jax.devices()[0].memory_stats()
+    if not stats:
+        return None
+    value = stats.get("peak_bytes_in_use")
+    return int(value) if value is not None else None
+
+
+def _assert_backend(allow_cpu: bool) -> str:
+    import jax
+
+    platform = jax.devices()[0].platform
+    if platform != "gpu" and not allow_cpu:
+        raise SmokeRuntimeError(f"admission smoke requires a GPU, observed {platform}")
+    return platform
+
+
+def _timed_upstream_training(
+    project_root: Path,
+    config: dict[str, Any],
+    batch: dict[str, np.ndarray],
+    *,
+    warmup_steps: int,
+    measured_steps: int,
+    identity_control: bool = False,
+) -> dict[str, Any]:
+    import jax
+
+    from sheaf_admm.models import model_config_from_dict
+    from sheaf_admm.training import build_model, create_train_state, make_task, make_train_step
+
+    task = make_task(config["task"], **config["task_cfg"])
+    fwd, targets, _ = task.prepare(batch)
+    model_config = model_config_from_dict(config["model"])
+    model = build_model(model_config, config["model_type"])
+    training = config["training"]
+    k_init = (
+        training["K_train"]
+        if config["model_type"] == "sheaf"
+        else training["mpnn_train_rounds"]
+    )
+    state = create_train_state(
+        model,
+        fwd,
+        model_type=config["model_type"],
+        lr=training["lr"],
+        weight_decay=training["weight_decay"],
+        warmup_steps=training["warmup_steps"],
+        grad_clip=training["grad_clip"],
+        ema_decay=training["ema_decay"],
+        k_init=k_init,
+        loss_window=training["loss_window"],
+        seed=training["seed"],
+    )
+    parity = None
+    if identity_control:
+        control_config = json.loads(json.dumps(config))
+        control_config["model"]["rm_init"] = "soft_slice"
+        control_config["model"]["rm_constant"] = False
+        control_model = build_model(model_config_from_dict(control_config["model"]), "sheaf")
+        control_state = create_train_state(
+            control_model,
+            fwd,
+            model_type="sheaf",
+            lr=training["lr"],
+            weight_decay=training["weight_decay"],
+            warmup_steps=training["warmup_steps"],
+            grad_clip=training["grad_clip"],
+            ema_decay=training["ema_decay"],
+            k_init=k_init,
+            loss_window=training["loss_window"],
+            seed=training["seed"],
+        )
+        counters = {"step": 0, "training_seed": training["seed"]}
+        assert_common_bit_identical(
+            control_state.params,
+            state.params,
+            control_state.opt_state,
+            state.opt_state,
+            counters,
+            counters,
+        )
+        parity = True
+    train_step = make_train_step(task, config["model_type"], model_config.mpnn_graph_readout)
+    rng = jax.random.PRNGKey(training["seed"])
+    k_step = (
+        training["K_train"]
+        if config["model_type"] == "sheaf"
+        else training["mpnn_train_rounds"]
+    )
+    for _ in range(warmup_steps):
+        rng, subkey = jax.random.split(rng)
+        state, loss = train_step(
+            state,
+            fwd,
+            targets,
+            subkey,
+            n_iter=k_step,
+            loss_window=training["loss_window"],
+        )
+        jax.block_until_ready(loss)
+    times = []
+    for _ in range(measured_steps):
+        rng, subkey = jax.random.split(rng)
+        started = time.perf_counter()
+        state, loss = train_step(
+            state,
+            fwd,
+            targets,
+            subkey,
+            n_iter=k_step,
+            loss_window=training["loss_window"],
+        )
+        jax.block_until_ready(loss)
+        times.append(time.perf_counter() - started)
+    return {
+        "parameter_count": sum(
+            int(leaf.size) for leaf in jax.tree_util.tree_leaves(state.params)
+        ),
+        "warmup_steps": warmup_steps,
+        "measured_steps": measured_steps,
+        "step_seconds": times,
+        "identity_common_parity": parity,
+        "jax_peak_bytes_in_use": _jax_peak_bytes(),
+    }
+
+
+def _cnn_training(
+    fixture: dict[str, np.ndarray],
+    *,
+    warmup_steps: int,
+    measured_steps: int,
+) -> dict[str, Any]:
+    import jax
+    import jax.numpy as jnp
+    import optax
+
+    from .cnn import (
+        count_parameters,
+        forward,
+        init_params,
+        kernel_weight_decay_mask,
+        masked_sparse_cross_entropy,
+    )
+
+    images = _repeat(fixture["images"], 128).astype(np.float32)
+    labels = _repeat(fixture["labels"], 128).astype(np.int32)
+    key = jax.random.PRNGKey(42)
+    params = init_params(key)
+    schedule = optax.join_schedules(
+        [optax.linear_schedule(0.0, 1e-3, 200), optax.constant_schedule(1e-3)],
+        [200],
+    )
+    optimizer = optax.chain(
+        optax.clip_by_global_norm(1.0),
+        optax.adamw(
+            schedule,
+            b1=0.9,
+            b2=0.999,
+            eps=1e-8,
+            weight_decay=1e-7,
+            mask=kernel_weight_decay_mask(params),
+        ),
+    )
+    optimizer_state = optimizer.init(params)
+    ema = jax.tree_util.tree_map(jnp.copy, params)
+    mask = np.ones(128, dtype=bool)
+
+    @jax.jit
+    def step(params, optimizer_state, ema):
+        loss, grads = jax.value_and_grad(
+            lambda value: masked_sparse_cross_entropy(
+                forward(value, images), labels, mask
+            )
+        )(params)
+        updates, optimizer_state = optimizer.update(grads, optimizer_state, params)
+        params = optax.apply_updates(params, updates)
+        ema = jax.tree_util.tree_map(lambda e, p: 0.999 * e + 0.001 * p, ema, params)
+        return params, optimizer_state, ema, loss
+
+    for _ in range(warmup_steps):
+        params, optimizer_state, ema, loss = step(params, optimizer_state, ema)
+        jax.block_until_ready(loss)
+    times = []
+    for _ in range(measured_steps):
+        started = time.perf_counter()
+        params, optimizer_state, ema, loss = step(params, optimizer_state, ema)
+        jax.block_until_ready(loss)
+        times.append(time.perf_counter() - started)
+    return {
+        "parameter_count": count_parameters(params),
+        "warmup_steps": warmup_steps,
+        "measured_steps": measured_steps,
+        "step_seconds": times,
+        "jax_peak_bytes_in_use": _jax_peak_bytes(),
+    }
+
+
+def _load_checkpoint(path: Path) -> dict[str, Any]:
+    with path.open("rb") as handle:
+        value = pickle.load(handle)
+        if handle.read(1):
+            raise SmokeRuntimeError("checkpoint contains trailing bytes")
+    if not isinstance(value, dict) or value.get("ema_params") is None:
+        raise SmokeRuntimeError("smoke checkpoint lacks EMA parameters")
+    return value
+
+
+def _mnist_forward_shapes(
+    fixture: dict[str, np.ndarray],
+    checkpoint_path: Path,
+    config_path: Path,
+) -> list[dict[str, Any]]:
+    import jax
+    import jax.numpy as jnp
+
+    from sheaf_admm.models import model_config_from_dict
+    from sheaf_admm.training import build_model, make_task
+    from sheaf_admm.training.loop import _forward
+
+    checkpoint = _load_checkpoint(checkpoint_path)
+    config = json.loads(config_path.read_text())
+    model_config = model_config_from_dict(config["model"])
+    model = build_model(model_config, "sheaf")
+    task = make_task("mnist", **config["task_cfg"])
+    params = checkpoint["ema_params"]
+    cases = [
+        ("clean", fixture["images"][:8], None),
+        ("pad16", fixture["pad16_images"][:2], None),
+        (
+            "drop30",
+            apply_patch_dropout(
+                fixture["images"][:8],
+                fixture["drop30_keep_mask"][:8],
+            ),
+            fixture["drop30_keep_mask"][:8],
+        ),
+    ]
+    results = []
+    for condition, images, keep_masks in cases:
+        batch: dict[str, Any] = {
+            "images": np.asarray(images, np.float32),
+            "labels": np.asarray(fixture["labels"][: len(images)], np.int32),
+        }
+        if keep_masks is not None:
+            batch["keep_masks"] = np.asarray(keep_masks, bool)
+        fwd, _, _ = task.prepare(batch)
+
+        @jax.jit
+        def run(current_params, current_fwd):
+            logits = _forward(
+                model.apply,
+                current_params,
+                current_fwd,
+                n_iter=100,
+                loss_window=1,
+                model_type="sheaf",
+                training=False,
+                rng=None,
+            )
+            return jnp.sum(logits[-1])
+
+        started = time.perf_counter()
+        value = run(params, fwd)
+        jax.block_until_ready(value)
+        results.append(
+            {
+                "condition": condition,
+                "shape": list(batch["images"].shape),
+                "compile_and_run_seconds": time.perf_counter() - started,
+            }
+        )
+    return results
+
+
+def run_family_child(
+    project_root: Path,
+    handoff: Path,
+    family: str,
+    *,
+    warmup_steps: int,
+    measured_steps: int,
+    allow_cpu: bool,
+) -> dict[str, Any]:
+    platform = _assert_backend(allow_cpu)
+    if family == "sudoku":
+        fixture = dict(
+            np.load(handoff / "smoke-fixtures/sudoku/optimizer-and-forward.npz")
+        )
+        batch = {
+            "inputs": _repeat(fixture["inputs"], 128),
+            "labels": _repeat(fixture["labels"], 128),
+        }
+        mpnn = registered_config_for(project_root, "C1-SUD-MPNN225-42")
+        identity = registered_config_for(project_root, "C4-SUD-IDENTITY-42")
+        workloads = {
+            "mpnn225": _timed_upstream_training(
+                project_root,
+                mpnn,
+                batch,
+                warmup_steps=warmup_steps,
+                measured_steps=measured_steps,
+            ),
+            "literal_identity": _timed_upstream_training(
+                project_root,
+                identity,
+                batch,
+                warmup_steps=warmup_steps,
+                measured_steps=measured_steps,
+                identity_control=True,
+            ),
+        }
+    elif family == "maze-c5":
+        fixture = dict(np.load(handoff / "smoke-fixtures/maze-c5/shape-19x19.npz"))
+        batch = {
+            "inputs": _repeat(fixture["inputs"], 128),
+            "labels": _repeat(fixture["labels"], 128),
+            "height": np.asarray(19),
+            "width": np.asarray(19),
+        }
+        mpnn = registered_config_for(project_root, "C2-MAZE-MPNN84-42")
+        quadratic = registered_config_for(project_root, "C4-MAZE-QUADRATIC-42")
+        workloads = {
+            "mpnn84": _timed_upstream_training(
+                project_root,
+                mpnn,
+                batch,
+                warmup_steps=warmup_steps,
+                measured_steps=measured_steps,
+            ),
+            "quadratic_no_l1": _timed_upstream_training(
+                project_root,
+                quadratic,
+                batch,
+                warmup_steps=warmup_steps,
+                measured_steps=measured_steps,
+            ),
+        }
+    elif family == "mnist":
+        fixture = dict(np.load(handoff / "smoke-fixtures/mnist/optimizer-and-forward.npz"))
+        checkpoint = handoff / "checkpoints/mnist-sheaf-seed-42/checkpoint.pkl"
+        config = handoff / "configs/mnist-sheaf-seed-42.json"
+        workloads = {
+            "cnn": _cnn_training(
+                fixture,
+                warmup_steps=warmup_steps,
+                measured_steps=measured_steps,
+            ),
+            "sheaf_evaluator_shapes": _mnist_forward_shapes(fixture, checkpoint, config),
+        }
+    else:
+        raise SmokeRuntimeError(f"unknown family {family}")
+    return {
+        "platform": platform,
+        "family": family,
+        "workloads": workloads,
+        "jax_peak_bytes_in_use": _jax_peak_bytes(),
+    }
+
+
+def run_c5_probe_child(
+    handoff: Path,
+    *,
+    size: int,
+    batch_size: int,
+    timing: bool,
+    allow_cpu: bool,
+) -> dict[str, Any]:
+    import jax
+    import jax.numpy as jnp
+
+    from sheaf_admm.models import model_config_from_dict
+    from sheaf_admm.training import build_model, make_task
+    from sheaf_admm.training.loop import _forward
+
+    platform = _assert_backend(allow_cpu)
+    fixture = dict(np.load(handoff / f"smoke-fixtures/maze-c5/shape-{size}x{size}.npz"))
+    batch = {
+        "inputs": _repeat(fixture["inputs"], batch_size),
+        "labels": _repeat(fixture["labels"], batch_size),
+        "height": np.asarray(size),
+        "width": np.asarray(size),
+    }
+    config_path = handoff / "configs/maze-sheaf-seed-42.json"
+    config = json.loads(config_path.read_text())
+    model_config = model_config_from_dict(config["model"])
+    model = build_model(model_config, "sheaf")
+    task = make_task("maze", **config["task_cfg"])
+    fwd, _, _ = task.prepare(batch)
+
+    @jax.jit
+    def run(params, current_fwd):
+        logits = _forward(
+            model.apply,
+            params,
+            current_fwd,
+            n_iter=100,
+            loss_window=1,
+            model_type="sheaf",
+            training=False,
+            rng=None,
+        )
+        return jnp.sum(logits[-1])
+
+    checkpoint_paths = [
+        handoff / f"checkpoints/maze-sheaf-seed-{seed}/checkpoint.pkl"
+        for seed in (42, 123, 456)
+    ]
+    params = [_load_checkpoint(path)["ema_params"] for path in checkpoint_paths]
+    compile_started = time.perf_counter()
+    compiled = run.lower(params[0], fwd).compile()
+    compile_seconds = time.perf_counter() - compile_started
+    first = compiled(params[0], fwd)
+    jax.block_until_ready(first)
+    times = []
+    if timing:
+        for current in params:
+            started = time.perf_counter()
+            value = compiled(current, fwd)
+            jax.block_until_ready(value)
+            times.append(time.perf_counter() - started)
+    return {
+        "platform": platform,
+        "size": size,
+        "batch_size": batch_size,
+        "compile_seconds": compile_seconds,
+        "post_compile_seconds": times,
+        "weight_swap_count": len(params) if timing else 1,
+        "compile_count": 1,
+        "jax_peak_bytes_in_use": _jax_peak_bytes(),
+    }
+
+
+def _nvidia_memory() -> tuple[int, int]:
+    command = [
+        "nvidia-smi",
+        "--query-gpu=memory.used,memory.total",
+        "--format=csv,noheader,nounits",
+    ]
+    result = subprocess.run(command, check=True, capture_output=True, text=True)
+    first = result.stdout.strip().splitlines()[0]
+    used_mib, total_mib = (int(part.strip()) for part in first.split(","))
+    return used_mib * 1024 * 1024, total_mib * 1024 * 1024
+
+
+def run_monitored(command: list[str], *, allow_cpu: bool) -> dict[str, Any]:
+    process = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        env={
+            **os.environ,
+            "XLA_PYTHON_CLIENT_PREALLOCATE": "false",
+            "XLA_PYTHON_CLIENT_ALLOCATOR": "platform",
+        },
+    )
+    peak_used = 0
+    total = 0
+    while process.poll() is None:
+        if not allow_cpu:
+            used, total = _nvidia_memory()
+            peak_used = max(peak_used, used)
+        time.sleep(0.1)
+    stdout, stderr = process.communicate()
+    if process.returncode != 0:
+        lowered = f"{stdout}\n{stderr}".lower()
+        classification = (
+            "RESOURCE_EXHAUSTION"
+            if any(term in lowered for term in ("out of memory", "resource_exhausted", "oom"))
+            else "CODE_OR_INFRASTRUCTURE"
+        )
+        return {
+            "success": False,
+            "classification": classification,
+            "returncode": process.returncode,
+            "stdout_tail": stdout[-4000:],
+            "stderr_tail": stderr[-4000:],
+            "nvml_peak_bytes": peak_used or None,
+            "nvml_total_bytes": total or None,
+        }
+    lines = [line for line in stdout.splitlines() if line.strip()]
+    if not lines:
+        raise SmokeRuntimeError("smoke child emitted no result")
+    try:
+        payload = json.loads(lines[-1])
+    except json.JSONDecodeError as exc:
+        raise SmokeRuntimeError(f"smoke child result is not JSON: {lines[-1]!r}") from exc
+    payload.update(
+        success=True,
+        nvml_peak_bytes=peak_used or None,
+        nvml_total_bytes=total or None,
+    )
+    return payload
+
+
+def orchestrate_family(
+    script: Path,
+    project_root: Path,
+    handoff: Path,
+    family: str,
+    *,
+    warmup_steps: int,
+    measured_steps: int,
+    allow_cpu: bool,
+) -> dict[str, Any]:
+    command = [
+        sys.executable,
+        str(script),
+        "--internal-family-child",
+        family,
+        "--project-root",
+        str(project_root),
+        "--handoff",
+        str(handoff),
+        "--steps-warmup",
+        str(warmup_steps),
+        "--steps-measured",
+        str(measured_steps),
+    ]
+    if allow_cpu:
+        command.append("--allow-cpu-preflight")
+    result = run_monitored(command, allow_cpu=allow_cpu)
+    if not result["success"]:
+        raise SmokeRuntimeError(
+            f"{family} workload child failed as {result['classification']}: "
+            f"{result['stderr_tail']}"
+        )
+    if family != "maze-c5":
+        return result
+
+    candidates = (1, 2, 4, 8, 16, 32, 64, 128)
+    selected: dict[int, Probe] = {}
+    probe_rows: dict[str, list[dict[str, Any]]] = {}
+    timing_rows: dict[str, dict[str, Any]] = {}
+    costs: dict[int, float] = {}
+    for size in C5_SIZES:
+        rows = []
+        probes = []
+        for batch_size in candidates:
+            command = [
+                sys.executable,
+                str(script),
+                "--internal-c5-probe-child",
+                "--handoff",
+                str(handoff),
+                "--size",
+                str(size),
+                "--batch-size",
+                str(batch_size),
+            ]
+            if allow_cpu:
+                command.append("--allow-cpu-preflight")
+            row = run_monitored(command, allow_cpu=allow_cpu)
+            rows.append(row)
+            if not row["success"]:
+                if row["classification"] != "RESOURCE_EXHAUSTION":
+                    raise SmokeRuntimeError(
+                        f"C5 {size}x{size} batch {batch_size} failed outside resource policy"
+                    )
+                break
+            peak_candidates = [
+                value
+                for value in (row.get("nvml_peak_bytes"), row.get("jax_peak_bytes_in_use"))
+                if value is not None
+            ]
+            peak = max(peak_candidates, default=0)
+            total = row.get("nvml_total_bytes") or max(peak, 1)
+            headroom = peak <= 0.8 * total
+            row["headroom_le_80_percent"] = headroom
+            if not headroom:
+                break
+            probes.append(
+                Probe(
+                    batch_size=batch_size,
+                    peak_bytes=peak,
+                    post_compile_seconds=(1.0, 1.0, 1.0),
+                    weight_swap_compile_counts=(1, 1, 1),
+                )
+            )
+        probe_rows[str(size)] = rows
+        accepted = select_batch(probes, rows[-1].get("nvml_total_bytes") or 2**63)
+        selected[size] = accepted
+        timing_command = [
+            sys.executable,
+            str(script),
+            "--internal-c5-probe-child",
+            "--handoff",
+            str(handoff),
+            "--size",
+            str(size),
+            "--batch-size",
+            str(accepted.batch_size),
+            "--timing",
+        ]
+        if allow_cpu:
+            timing_command.append("--allow-cpu-preflight")
+        timing = run_monitored(timing_command, allow_cpu=allow_cpu)
+        if not timing["success"]:
+            raise SmokeRuntimeError(f"accepted C5 timing probe failed for size {size}")
+        timing_rows[str(size)] = timing
+        guarded_batch = 1.10 * max(timing["post_compile_seconds"])
+        costs[size] = (
+            timing["compile_seconds"]
+            + 3 * ((1000 + accepted.batch_size - 1) // accepted.batch_size) * guarded_batch
+            + 30.0
+        )
+    result["c5"] = {
+        "candidate_probes": probe_rows,
+        "accepted": {
+            str(size): {
+                "batch_size": probe.batch_size,
+                "peak_bytes": probe.peak_bytes,
+                "timing": timing_rows[str(size)],
+                "guarded_cost_seconds": costs[size],
+            }
+            for size, probe in selected.items()
+        },
+        "lpt_shards": deterministic_lpt(costs),
+    }
+    return result
+
+
+def fixture_hashes(handoff: Path) -> dict[str, str]:
+    registry = json.loads((handoff / "SMOKE-FIXTURES.json").read_text())
+    return {row["path"]: sha256_file(handoff / row["path"]) for row in registry["entries"]}
diff --git a/src/sheaf_admm/__init__.py b/src/sheaf_admm/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b7772c477ec26fc25f28218e54652a74154ae250
--- /dev/null
+++ b/src/sheaf_admm/__init__.py
@@ -0,0 +1,23 @@
+"""Sheaf-ADMM: learning multi-agent coordination via sheaf-constrained ADMM.
+
+A differentiable optimization framework. An input is decomposed into overlapping
+local views, each processed by an agent that solves a convex subproblem
+parameterized by a shared neural encoder. Agents coordinate through ADMM with
+inter-agent constraints specified by a cellular sheaf, and a shared decoder maps
+the final agent states back to a global prediction. The whole pipeline is
+differentiable and trained end-to-end.
+
+Reference implementation for "Learning Multi-Agent Coordination via Sheaf-ADMM"
+(ICML 2026).
+"""
+
+from __future__ import annotations
+
+from .precision import set_high_precision
+
+# Enforce true float32 matmuls before any compilation happens (see precision.py).
+set_high_precision()
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__", "set_high_precision"]
diff --git a/src/sheaf_admm/admm.py b/src/sheaf_admm/admm.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb9e3d392db879eff093bdb82bcf3793829a1341
--- /dev/null
+++ b/src/sheaf_admm/admm.py
@@ -0,0 +1,182 @@
+"""The unrolled ADMM loop — the coordination core.
+
+Each agent carries three states: the local proposal ``x``, the consensus iterate
+``z``, and the scaled dual accumulator ``y`` (``u = lambda / rho``). One ADMM
+iteration is::
+
+    z_prev = z
+    x       = prox_f(z - y; rho)                       # local x-update (x-solver)
+    x_relax = alpha * x + (1 - alpha) * z_prev          # optional over-relaxation
+    z       = consensus(x_relax + y; geometry, rho)     # sheaf z-update (z-solver)
+    y       = y + (x_relax - z)                          # dual ascent
+
+We unroll ``K`` iterations and backpropagate through the whole trajectory. The
+loss is computed from the final ``loss_window`` x-iterates (decoded and
+averaged), so the loop returns those. Memory options:
+
+* full unroll (``grad_window=None``): gradients flow through all ``K`` steps.
+* truncated BPTT (``grad_window=g``): the first ``K-g`` steps run detached
+  (``stop_gradient``); gradients flow only through the last ``g``. Memory is
+  ``O(g)`` instead of ``O(K)``.
+
+Either way only the last ``loss_window`` x-iterates are materialized.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import jax
+import jax.numpy as jnp
+from flax import struct
+
+from sheaf_admm.geometry.base import SheafGeometry
+from sheaf_admm.solvers.base import XSolver, XSolverParams, ZSolver, ZSolverParams
+
+
+@struct.dataclass
+class ADMMState:
+    """Per-agent ADMM variables, each ``[N, B, d_v]``."""
+
+    x: jnp.ndarray  # local proposal (primal)
+    z: jnp.ndarray  # consensus iterate
+    y: jnp.ndarray  # scaled dual accumulator (u = lambda / rho)
+
+
+def inverse_softplus(x: float) -> float:
+    """Numerically safe inverse of softplus, for initializing softplus-parameterized scalars.
+
+    Guards ``log(expm1(x))`` against underflow (clamp to >=1e-7) and overflow
+    (identity for large x), so any positive init value maps to a finite raw param.
+    """
+    x = max(x, 1e-7)
+    return x if x > 20.0 else math.log(math.expm1(x))
+
+
+def run_admm(
+    encoder_output: dict[str, Any],
+    geometry: SheafGeometry,
+    x_solver: XSolver,
+    x_params: XSolverParams,
+    z_solver: ZSolver,
+    z_params: ZSolverParams,
+    rho: jnp.ndarray,
+    z_init: jnp.ndarray,  # [N, B, d_v] initial consensus state (encoder h, or zeros)
+    num_iters: int,
+    *,
+    relaxation_alpha: float = 1.0,
+    loss_window: int = 1,
+    grad_window: int | None = None,
+) -> tuple[ADMMState, jnp.ndarray]:
+    """Run ``num_iters`` ADMM steps.
+
+    Returns the final :class:`ADMMState` and the stacked last ``loss_window``
+    local proposals ``x`` of shape ``[W, N, B, d_v]`` (oldest first).
+    """
+    alpha = relaxation_alpha
+
+    def step(state: ADMMState) -> ADMMState:
+        z_prev = state.z
+        x = x_solver.solve(state.z, state.y, rho, encoder_output, x_params)
+        x_relaxed = x if alpha == 1.0 else alpha * x + (1.0 - alpha) * z_prev
+        z_target = x_relaxed + state.y
+        z = z_solver.solve(z_target, z_prev, geometry, z_params, rho)
+        y = state.y + (x_relaxed - z)
+        return ADMMState(x=x, z=z, y=y)
+
+    state = ADMMState(x=z_init, z=z_init, y=jnp.zeros_like(z_init))
+
+    K = num_iters
+    n_detached = 0 if grad_window is None else max(0, K - grad_window)
+    if n_detached > 0:
+        state = jax.lax.fori_loop(0, n_detached, lambda _i, s: step(s), state)
+        state = jax.tree_util.tree_map(jax.lax.stop_gradient, state)
+
+    n_grad = K - n_detached
+    window = min(loss_window, n_grad)
+    n_pre = n_grad - window
+    if n_pre > 0:
+        state, _ = jax.lax.scan(lambda s, _: (step(s), None), state, None, length=n_pre)
+
+    def collect(s, _):
+        ns = step(s)
+        return ns, ns.x
+
+    state, x_window = jax.lax.scan(collect, state, None, length=window)
+    return state, x_window
+
+
+@struct.dataclass
+class ADMMHistory:
+    """Per-iteration ADMM trajectory, for visualization / convergence diagnostics.
+
+    All arrays stack the ``K`` iterations on a leading axis (oldest first). The
+    per-agent state arrays are ``[K, N, B, d_v]``; the residual arrays are the
+    standard ADMM stopping diagnostics:
+
+    * ``primal_res = ||x_relaxed - z||`` per agent (``[K, N, B]``) — how far the
+      local proposal sits from the consensus it agreed to.
+    * ``dual_res = rho * ||z - z_prev||`` per agent (``[K, N, B]``) — the change
+      in the consensus iterate, scaled by the penalty (the dual feasibility
+      residual of scaled-dual ADMM).
+    * ``consistency_rms`` (``[K, B]``) — the geometry's sheaf-disagreement RMS,
+      ``sqrt(mean over edges and stalk dims of r^2 + eps)``, the quantity the
+      model is trained to drive to zero.
+    """
+
+    x: jnp.ndarray  # [K, N, B, d_v] local proposals
+    z: jnp.ndarray  # [K, N, B, d_v] consensus iterates
+    y: jnp.ndarray  # [K, N, B, d_v] scaled duals
+    primal_res: jnp.ndarray  # [K, N, B] ||x_relaxed - z|| per agent
+    dual_res: jnp.ndarray  # [K, N, B] rho * ||z - z_prev|| per agent
+    consistency_rms: jnp.ndarray  # [K, B] sheaf disagreement RMS
+
+
+def run_admm_history(
+    encoder_output: dict[str, Any],
+    geometry: SheafGeometry,
+    x_solver: XSolver,
+    x_params: XSolverParams,
+    z_solver: ZSolver,
+    z_params: ZSolverParams,
+    rho: jnp.ndarray,
+    z_init: jnp.ndarray,
+    num_iters: int,
+    *,
+    relaxation_alpha: float = 1.0,
+) -> tuple[ADMMState, ADMMHistory]:
+    """Run ``num_iters`` ADMM steps, recording the full per-iteration trajectory.
+
+    Same fixed-point iteration as :func:`run_admm`, but every iterate and its
+    primal/dual residuals are stacked and returned in an :class:`ADMMHistory`
+    (no gradient window — this is a forward-only diagnostic path). Use it to
+    visualize coordination dynamics and x-vs-z trajectories on a single example.
+    """
+    alpha = relaxation_alpha
+    rho_s = jnp.asarray(rho)
+
+    def step(state: ADMMState, _):
+        z_prev = state.z
+        x = x_solver.solve(state.z, state.y, rho, encoder_output, x_params)
+        x_relaxed = x if alpha == 1.0 else alpha * x + (1.0 - alpha) * z_prev
+        z_target = x_relaxed + state.y
+        z = z_solver.solve(z_target, z_prev, geometry, z_params, rho)
+        y = state.y + (x_relaxed - z)
+        new = ADMMState(x=x, z=z, y=y)
+        primal_res = jnp.linalg.norm(x_relaxed - z, axis=-1)  # [N, B]
+        dual_res = rho_s * jnp.linalg.norm(z - z_prev, axis=-1)  # [N, B]
+        crms = geometry.consistency_rms(z)  # [B]
+        return new, (new, primal_res, dual_res, crms)
+
+    state = ADMMState(x=z_init, z=z_init, y=jnp.zeros_like(z_init))
+    state, (states, primal_res, dual_res, crms) = jax.lax.scan(step, state, None, length=num_iters)
+    history = ADMMHistory(
+        x=states.x,
+        z=states.z,
+        y=states.y,
+        primal_res=primal_res,
+        dual_res=dual_res,
+        consistency_rms=crms,
+    )
+    return state, history
diff --git a/src/sheaf_admm/data/__init__.py b/src/sheaf_admm/data/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1638755aec2f319b4162aadcc4f94f51340bb375
--- /dev/null
+++ b/src/sheaf_admm/data/__init__.py
@@ -0,0 +1,76 @@
+"""Data layer: views (grid <-> agents), on-disk loaders, and dataset builders.
+
+* :mod:`~sheaf_admm.data.views` — the global-grid <-> per-agent map for maze /
+  MNIST (grid patches) and Sudoku (constraint slices), plus reassembly and the
+  agent graphs.
+* :mod:`~sheaf_admm.data.loaders` — memory-mapped :class:`ImageDataset` and
+  :class:`PuzzleDataset` with format-contract validation.
+* ``build_maze`` / ``build_mnist`` / ``build_sudoku`` — argparse CLIs (run via
+  ``python -m sheaf_admm.data.build_*``) for local/toy dataset generation.
+"""
+
+from __future__ import annotations
+
+from .common import (
+    DIHEDRAL_INVERSE,
+    SUDOKU_VOCAB_SIZE,
+    TOKEN_IDS,
+    PuzzleDatasetMetadata,
+    dihedral_transform,
+    inverse_dihedral_transform,
+    save_json,
+    save_npy,
+    shuffle_in_unison,
+)
+from .loaders import ImageDataset, PuzzleDataset, PuzzleSet
+from .views import (
+    build_grid_edge_indices,
+    build_sudoku_cell_indices,
+    build_sudoku_multigraph,
+    get_agent_label_patches_jax,
+    get_cached_sudoku_graph,
+    grid_agent_centers,
+    infer_image_hw,
+    node_positions,
+    patchify_batch_jax,
+    prepare_maze_patches,
+    reassemble_logits,
+    reassemble_sudoku_logits,
+    sudoku_node_positions,
+    sudoku_num_nodes,
+    sudoku_slice_batch_jax,
+)
+
+__all__ = [
+    # common
+    "TOKEN_IDS",
+    "SUDOKU_VOCAB_SIZE",
+    "DIHEDRAL_INVERSE",
+    "PuzzleDatasetMetadata",
+    "dihedral_transform",
+    "inverse_dihedral_transform",
+    "save_json",
+    "save_npy",
+    "shuffle_in_unison",
+    # loaders
+    "ImageDataset",
+    "PuzzleDataset",
+    "PuzzleSet",
+    # views: grid
+    "grid_agent_centers",
+    "patchify_batch_jax",
+    "build_grid_edge_indices",
+    "node_positions",
+    "reassemble_logits",
+    "get_agent_label_patches_jax",
+    "prepare_maze_patches",
+    "infer_image_hw",
+    # views: sudoku
+    "sudoku_slice_batch_jax",
+    "reassemble_sudoku_logits",
+    "build_sudoku_multigraph",
+    "get_cached_sudoku_graph",
+    "build_sudoku_cell_indices",
+    "sudoku_num_nodes",
+    "sudoku_node_positions",
+]
diff --git a/src/sheaf_admm/data/build_maze.py b/src/sheaf_admm/data/build_maze.py
new file mode 100644
index 0000000000000000000000000000000000000000..3114017e653393e4fdce51430a5c62d3633ee723
--- /dev/null
+++ b/src/sheaf_admm/data/build_maze.py
@@ -0,0 +1,370 @@
+"""Perfect-maze builder: DFS carve, BFS shortest path, dihedral augmentation.
+
+A "perfect" maze (unique path between any two cells) is carved by randomized
+DFS backtracking. Start/goal are sampled from open cells; the shortest path is
+found by BFS and accepted only if ``len(path) - 1 >= min_path_length`` (the
+default 18 matches the paper's 19x19 ``std3`` sets). Each accepted base maze is
+written under all admissible dihedral symmetries (square mazes use all 8;
+rectangles use the 4 that preserve the aspect ratio).
+
+On-disk format is the TRM standard token layout (one int per cell, vocab 6):
+``inputs`` carry wall/empty/start/goal (1-4), ``labels`` add the path token (5).
+
+Size generalization is built in: ``--ood-sizes`` writes the train + standard
+OOD suite (1.5x/2x/4x larger boards, with ``_long`` variants demanding longer
+paths) in one run.
+
+Usage:
+    python -m sheaf_admm.data.build_maze --height 19 --width 19 \
+        --min-path-length 18 --train-size 10000 --test-size 1000 \
+        --output-dir datasets/maze_std3_19px_10k --ood-sizes
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections.abc import Iterable, Sequence
+from dataclasses import asdict, dataclass, replace
+from pathlib import Path
+
+import numpy as np
+
+from .common import (
+    TOKEN_IDS,
+    PuzzleDatasetMetadata,
+    dihedral_transform,
+    save_npy,
+)
+
+
+@dataclass
+class MazeConfig:
+    height: int = 19
+    width: int = 19
+    train_size: int = 10000
+    test_size: int = 1000
+    min_path_length: int = 18
+    train_augment: bool = True
+    test_augment: bool = False
+    seed: int = 0
+    max_retries: int = 200
+    output_dir: Path = Path("datasets/maze")
+
+    def to_dict(self) -> dict:
+        payload = asdict(self)
+        payload["output_dir"] = str(self.output_dir)
+        return payload
+
+
+# --- maze generation ---------------------------------------------------------
+
+
+def _neighbors(cell: tuple[int, int]) -> Iterable[tuple[int, int]]:
+    r, c = cell
+    for dr, dc in ((2, 0), (-2, 0), (0, 2), (0, -2)):
+        yield r + dr, c + dc
+
+
+def _backtrack_maze(height: int, width: int, rng: np.random.Generator) -> np.ndarray:
+    """Carve a perfect maze by randomized DFS on the odd-index lattice."""
+    grid = np.full((height, width), TOKEN_IDS["wall"], dtype=np.int8)
+    odd_rows = list(range(1, height, 2))
+    odd_cols = list(range(1, width, 2))
+    start_r, start_c = int(rng.choice(odd_rows)), int(rng.choice(odd_cols))
+    grid[start_r, start_c] = TOKEN_IDS["empty"]
+    stack = [(start_r, start_c)]
+    while stack:
+        r, c = stack[-1]
+        unvisited = [
+            (nr, nc)
+            for nr, nc in _neighbors((r, c))
+            if 0 < nr < height
+            and 0 < nc < width
+            and grid[nr, nc] == TOKEN_IDS["wall"]
+            and nr in odd_rows
+            and nc in odd_cols
+        ]
+        if not unvisited:
+            stack.pop()
+            continue
+        nr, nc = unvisited[int(rng.integers(len(unvisited)))]
+        grid[r + (nr - r) // 2, c + (nc - c) // 2] = TOKEN_IDS["empty"]
+        grid[nr, nc] = TOKEN_IDS["empty"]
+        stack.append((nr, nc))
+    return grid
+
+
+def _shortest_path(
+    grid: np.ndarray, start: tuple[int, int], goal: tuple[int, int]
+) -> list[tuple[int, int]]:
+    """BFS shortest path over open cells; empty list if unreachable."""
+    h, w = grid.shape
+    queue: list[tuple[int, int]] = [start]
+    parent: dict[tuple[int, int], tuple[int, int]] = {}
+    visited = np.zeros_like(grid, dtype=bool)
+    visited[start] = True
+    for pos in queue:
+        if pos == goal:
+            break
+        r, c = pos
+        for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
+            nr, nc = r + dr, c + dc
+            if (
+                0 <= nr < h
+                and 0 <= nc < w
+                and not visited[nr, nc]
+                and grid[nr, nc] != TOKEN_IDS["wall"]
+            ):
+                visited[nr, nc] = True
+                parent[(nr, nc)] = (r, c)
+                queue.append((nr, nc))
+    if goal not in parent and start != goal:
+        return []
+    path = [goal]
+    cur = goal
+    while cur != start:
+        cur = parent[cur]
+        path.append(cur)
+    path.reverse()
+    return path
+
+
+def _pick_positions(
+    grid: np.ndarray, rng: np.random.Generator
+) -> tuple[tuple[int, int], tuple[int, int]]:
+    empties = np.argwhere(grid == TOKEN_IDS["empty"])
+    if len(empties) < 2:
+        raise ValueError("Maze too small for start/goal placement.")
+    start_idx, goal_idx = rng.choice(len(empties), size=2, replace=False)
+    return tuple(int(x) for x in empties[start_idx]), tuple(int(x) for x in empties[goal_idx])
+
+
+def _paint_grid(
+    base: np.ndarray,
+    start: tuple[int, int],
+    goal: tuple[int, int],
+    path: Sequence[tuple[int, int]],
+    with_path: bool,
+) -> np.ndarray:
+    """Paint start/goal (and optionally the path) onto a copy of the maze."""
+    painted = base.copy()
+    (sr, sc), (gr, gc) = start, goal
+    if with_path:
+        for r, c in path:
+            painted[r, c] = TOKEN_IDS["path"]
+    painted[sr, sc] = TOKEN_IDS["start"]
+    painted[gr, gc] = TOKEN_IDS["goal"]
+    return painted
+
+
+# --- split assembly ----------------------------------------------------------
+
+
+def _dihedral_variants(height: int, width: int, augment: bool) -> list[int]:
+    if not augment:
+        return [0]
+    if height == width:
+        return list(range(8))
+    return [0, 2, 4, 5]  # identity, 180-rot, hflip, vflip (preserve aspect ratio)
+
+
+def _build_split(
+    split: str,
+    count: int,
+    cfg: MazeConfig,
+    rng: np.random.Generator,
+    seen_hashes: set,
+    apply_augmentation: bool,
+) -> None:
+    output_root = cfg.output_dir / split
+    inputs: list[np.ndarray] = []
+    labels: list[np.ndarray] = []
+    puzzle_indices: list[int] = [0]
+    group_indices: list[int] = [0]
+    puzzle_identifiers: list[int] = []
+    total_examples = 0
+    aug_variants = _dihedral_variants(cfg.height, cfg.width, apply_augmentation)
+
+    for puzzle_id in range(count):
+        base_grid = start = goal = path = None
+        for _ in range(cfg.max_retries * 4):
+            grid = _backtrack_maze(cfg.height, cfg.width, rng)
+            grid_hash = hash(grid.tobytes())
+            if grid_hash in seen_hashes:
+                continue
+            s, g = _pick_positions(grid, rng)
+            p = _shortest_path(grid, s, g)
+            if p and len(p) - 1 >= cfg.min_path_length:
+                seen_hashes.add(grid_hash)
+                base_grid, start, goal, path = grid, s, g, p
+                break
+        if base_grid is None:
+            raise RuntimeError(
+                f"Failed to generate maze with min_path_length={cfg.min_path_length}"
+            )
+
+        for k in aug_variants:
+            input_grid = _paint_grid(base_grid, start, goal, path, with_path=False)
+            label_grid = _paint_grid(base_grid, start, goal, path, with_path=True)
+            if k != 0:
+                input_grid = dihedral_transform(input_grid, k)
+                label_grid = dihedral_transform(label_grid, k)
+            inputs.append(input_grid.astype(np.uint8).reshape(-1))
+            labels.append(label_grid.astype(np.uint8).reshape(-1))
+            total_examples += 1
+
+        puzzle_indices.append(total_examples)
+        group_indices.append(puzzle_id + 1)
+        puzzle_identifiers.append(0)
+
+    inputs_arr = np.stack(inputs)
+    labels_arr = np.stack(labels)
+    save_npy(output_root / "all__inputs.npy", inputs_arr)
+    save_npy(output_root / "all__labels.npy", labels_arr)
+    save_npy(output_root / "all__puzzle_indices.npy", np.array(puzzle_indices, dtype=np.int32))
+    save_npy(output_root / "all__group_indices.npy", np.array(group_indices, dtype=np.int32))
+    save_npy(
+        output_root / "all__puzzle_identifiers.npy", np.array(puzzle_identifiers, dtype=np.int32)
+    )
+
+    metadata = PuzzleDatasetMetadata(
+        pad_id=0,
+        ignore_label_id=0,
+        blank_identifier_id=0,
+        vocab_size=max(TOKEN_IDS.values()) + 1,
+        seq_len=cfg.height * cfg.width,
+        num_puzzle_identifiers=1,
+        total_groups=len(group_indices) - 1,
+        mean_puzzle_examples=total_examples / max(count, 1),
+        total_puzzles=count,
+        sets=["all"],
+        height=cfg.height,
+        width=cfg.width,
+    )
+    metadata.write(output_root / "dataset.json")
+    print(
+        json.dumps(
+            {
+                "split": split,
+                "examples": int(inputs_arr.shape[0]),
+                "puzzles": int(count),
+                "input_seq_len": int(inputs_arr.shape[1]),
+            },
+            indent=2,
+        )
+    )
+
+
+# --- spec-builder API (used by build_dataset specs) --------------------------
+
+
+def default_config() -> MazeConfig:
+    return MazeConfig()
+
+
+def build_split(
+    cfg: MazeConfig,
+    split: str,
+    count: int,
+    rng: np.random.Generator | None = None,
+    seen_hashes: set | None = None,
+    apply_augmentation: bool | None = None,
+) -> None:
+    if rng is None:
+        rng = np.random.default_rng(cfg.seed)
+    if seen_hashes is None:
+        seen_hashes = set()
+    if apply_augmentation is None:
+        apply_augmentation = cfg.train_augment if split == "train" else cfg.test_augment
+    _build_split(split, count, cfg, rng, seen_hashes, apply_augmentation)
+
+
+# --- standard OOD size-generalization suite ----------------------------------
+
+# (split, height, width, min_path_length, seed) relative to a 19x19 base — the
+# paper's std3 size-generalization grid. Scaled boards keep ~1-cell border via
+# odd dimensions; ``_long`` variants demand longer paths at the same size.
+_OOD_SUITE: list[tuple[str, int, int, int, int]] = [
+    ("test_ood_1.5x", 29, 29, 42, 2000),
+    ("test_ood_2x", 37, 37, 36, 3500),
+    ("test_ood_2x_long", 37, 37, 54, 3600),
+    ("test_ood_2xW", 19, 37, 35, 3000),
+    ("test_ood_4xW", 19, 73, 69, 4000),
+    ("test_ood_4x", 73, 73, 72, 5000),
+    ("test_ood_4x_long", 73, 73, 109, 6000),
+]
+
+
+def build(cfg: MazeConfig, ood_sizes: bool = False) -> None:
+    """Build the train split, the same-size test split, and optionally the OOD suite."""
+    cfg.output_dir.mkdir(parents=True, exist_ok=True)
+    seen_hashes: set = set()
+
+    build_split(
+        cfg,
+        "train",
+        cfg.train_size,
+        rng=np.random.default_rng(cfg.seed),
+        seen_hashes=seen_hashes,
+        apply_augmentation=cfg.train_augment,
+    )
+    build_split(
+        cfg,
+        "test",
+        cfg.test_size,
+        rng=np.random.default_rng(cfg.seed + 1000),
+        seen_hashes=seen_hashes,
+        apply_augmentation=cfg.test_augment,
+    )
+
+    if ood_sizes:
+        for name, h, w, mpl, seed in _OOD_SUITE:
+            ood_cfg = replace(cfg, height=h, width=w, min_path_length=mpl, seed=seed)
+            build_split(
+                ood_cfg,
+                name,
+                cfg.test_size,
+                rng=np.random.default_rng(seed),
+                seen_hashes=set(),
+                apply_augmentation=False,
+            )
+    print("Done.")
+
+
+def parse_args() -> tuple[MazeConfig, bool]:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--height", type=int, default=MazeConfig.height)
+    parser.add_argument("--width", type=int, default=MazeConfig.width)
+    parser.add_argument("--train-size", type=int, default=MazeConfig.train_size)
+    parser.add_argument("--test-size", type=int, default=MazeConfig.test_size)
+    parser.add_argument("--min-path-length", type=int, default=MazeConfig.min_path_length)
+    parser.add_argument("--seed", type=int, default=MazeConfig.seed)
+    parser.add_argument("--max-retries", type=int, default=MazeConfig.max_retries)
+    parser.add_argument("--output-dir", type=Path, default=MazeConfig.output_dir)
+    parser.add_argument("--no-train-augment", action="store_true")
+    parser.add_argument("--test-augment", action="store_true")
+    parser.add_argument(
+        "--ood-sizes",
+        action="store_true",
+        help="Also build the standard size-generalization OOD suite.",
+    )
+    args = parser.parse_args()
+    cfg = MazeConfig(
+        height=args.height,
+        width=args.width,
+        train_size=args.train_size,
+        test_size=args.test_size,
+        min_path_length=args.min_path_length,
+        train_augment=not args.no_train_augment,
+        test_augment=args.test_augment,
+        seed=args.seed,
+        max_retries=args.max_retries,
+        output_dir=args.output_dir,
+    )
+    return cfg, args.ood_sizes
+
+
+if __name__ == "__main__":
+    _cfg, _ood = parse_args()
+    build(_cfg, ood_sizes=_ood)
diff --git a/src/sheaf_admm/data/build_mnist.py b/src/sheaf_admm/data/build_mnist.py
new file mode 100644
index 0000000000000000000000000000000000000000..d15c6dfc5d0282ed8dd14d082ecf39c03fe7a231
--- /dev/null
+++ b/src/sheaf_admm/data/build_mnist.py
@@ -0,0 +1,157 @@
+"""Materialize MNIST into NumPy caches for the :class:`ImageDataset` loader.
+
+Images are reshaped to ``[N, 28+2p, 28+2p, 1]`` and normalized to ``[0, 1]``
+(divide by 255). ``--gen-robustness`` additionally writes the generalization
+suite used in the paper: padding splits (``test_pad_{2,4,8,12,16}``, which change
+the spatial shape — hence ``split_shapes`` in the metadata) and additive-Gaussian
+noise splits (``test_noise_{0.1..0.5}``, clipped back to ``[0, 1]``).
+
+Usage:
+    python -m sheaf_admm.data.build_mnist --output-dir datasets/mnist --gen-robustness
+"""
+
+from __future__ import annotations
+
+import argparse
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+import numpy as np
+
+from .common import save_json, save_npy, shuffle_in_unison
+
+PAD_LEVELS = (2, 4, 8, 12, 16)
+NOISE_LEVELS = (0.1, 0.2, 0.3, 0.4, 0.5)
+
+
+@dataclass
+class MNISTConfig:
+    padding: int = 0
+    seed: int = 0
+    normalize: bool = True
+    gen_robustness: bool = False
+    output_dir: Path = Path("datasets/mnist")
+
+    def to_dict(self):
+        payload = asdict(self)
+        payload["output_dir"] = str(self.output_dir)
+        return payload
+
+
+def _load_mnist_arrays() -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    import ml_datasets
+
+    data = ml_datasets.mnist()
+    if isinstance(data, tuple) and len(data) == 2 and isinstance(data[0], tuple):
+        (train_images, train_labels), (test_images, test_labels) = data
+    elif isinstance(data, tuple) and len(data) == 4:
+        train_images, train_labels, test_images, test_labels = data
+    else:
+        raise ValueError("Unexpected ml_datasets.mnist() return format.")
+    return tuple(np.asarray(x) for x in (train_images, train_labels, test_images, test_labels))
+
+
+def _prep_images(images: np.ndarray, padding: int, normalize: bool) -> np.ndarray:
+    """Reshape to ``[N, H, W, 1]`` float32, normalize to ``[0, 1]``, zero-pad."""
+    images = images.astype(np.float32)
+    if normalize and images.max() > 1.0:
+        images = images / 255.0
+    images = images.reshape((-1, 28, 28, 1))
+    if padding > 0:
+        images = np.pad(
+            images,
+            ((0, 0), (padding, padding), (padding, padding), (0, 0)),
+            mode="constant",
+            constant_values=0.0,
+        )
+    return images
+
+
+def _save_split(root: Path, name: str, images: np.ndarray, labels: np.ndarray) -> None:
+    save_npy(root / name / "images.npy", images)
+    save_npy(root / name / "labels.npy", labels)
+
+
+def build(cfg: MNISTConfig) -> None:
+    rng = np.random.default_rng(cfg.seed)
+    raw_train_img, raw_train_lbl, raw_test_img, raw_test_lbl = _load_mnist_arrays()
+
+    train_labels = raw_train_lbl.astype(np.int64)
+    test_labels = raw_test_lbl.astype(np.int64)
+    if train_labels.ndim > 1:
+        train_labels = np.argmax(train_labels, axis=-1)
+    if test_labels.ndim > 1:
+        test_labels = np.argmax(test_labels, axis=-1)
+
+    splits_meta: dict[str, int] = {}
+    split_shapes: dict[str, list[int]] = {}
+
+    train_images = _prep_images(raw_train_img, cfg.padding, cfg.normalize)
+    test_images = _prep_images(raw_test_img, cfg.padding, cfg.normalize)
+    train_images, train_labels = shuffle_in_unison(rng, train_images, train_labels)
+
+    _save_split(cfg.output_dir, "train", train_images, train_labels)
+    _save_split(cfg.output_dir, "test", test_images, test_labels)
+    for name, imgs in (("train", train_images), ("test", test_images)):
+        splits_meta[name] = int(imgs.shape[0])
+        split_shapes[name] = list(imgs.shape[1:])
+
+    if cfg.gen_robustness:
+        for pad in PAD_LEVELS:
+            total_pad = cfg.padding + pad
+            name = f"test_pad_{total_pad}"
+            images_pad = _prep_images(raw_test_img, total_pad, cfg.normalize)
+            _save_split(cfg.output_dir, name, images_pad, test_labels)
+            splits_meta[name] = int(images_pad.shape[0])
+            split_shapes[name] = list(images_pad.shape[1:])
+
+        for sigma in NOISE_LEVELS:
+            name = f"test_noise_{sigma}"
+            noise = rng.normal(0.0, sigma, size=test_images.shape).astype(np.float32)
+            images_noisy = np.clip(test_images + noise, 0.0, 1.0)
+            _save_split(cfg.output_dir, name, images_noisy, test_labels)
+            splits_meta[name] = int(images_noisy.shape[0])
+            split_shapes[name] = list(images_noisy.shape[1:])
+
+    save_json(
+        cfg.output_dir / "metadata.json",
+        {
+            "task": "mnist",
+            "image_shape": list(train_images.shape[1:]),
+            "num_classes": 10,
+            "padding": cfg.padding,
+            "seed": cfg.seed,
+            "normalize": cfg.normalize,
+            "splits": splits_meta,
+            "split_shapes": split_shapes,
+            "config": cfg.to_dict(),
+        },
+    )
+    print(f"MNIST cached to {cfg.output_dir}; splits: {list(splits_meta.keys())}")
+
+
+def parse_args() -> MNISTConfig:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--padding", type=int, default=MNISTConfig.padding)
+    parser.add_argument("--seed", type=int, default=MNISTConfig.seed)
+    parser.add_argument(
+        "--no-normalize", action="store_true", help="Skip division by 255 (keep range 0..255)."
+    )
+    parser.add_argument(
+        "--gen-robustness",
+        action="store_true",
+        help="Also build padding/noise generalization splits.",
+    )
+    parser.add_argument("--output-dir", type=Path, default=MNISTConfig.output_dir)
+    args = parser.parse_args()
+    return MNISTConfig(
+        padding=args.padding,
+        seed=args.seed,
+        normalize=not args.no_normalize,
+        gen_robustness=args.gen_robustness,
+        output_dir=args.output_dir,
+    )
+
+
+if __name__ == "__main__":
+    build(parse_args())
diff --git a/src/sheaf_admm/data/build_sudoku.py b/src/sheaf_admm/data/build_sudoku.py
new file mode 100644
index 0000000000000000000000000000000000000000..41502aeaf509b40d2e7823fd3178a647e708f86f
--- /dev/null
+++ b/src/sheaf_admm/data/build_sudoku.py
@@ -0,0 +1,214 @@
+"""Sudoku builder: download HF ``Ritvik19/Sudoku-Dataset``, take first N, augment.
+
+The dataset (~2.2 GB parquet, ~17M rows) is downloaded once and iterated locally
+(HF streaming was much slower in replication runs), filtered to
+``difficulty <= difficulty_max`` (default 2.0 — note ``difficulty`` is binary 0/1
+in this dataset, so the filter passes *everything*: "easy" is effectively "the first
+N puzzles"), and each kept puzzle is parsed from its
+81-char string into a 9x9 token grid (``'.' -> 0``, ``'1'-'9' -> 1-9``; vocab 10).
+Train and test draw from one shared iterator so the splits never overlap; the test
+split is named ``test_hard``. Train puzzles are written under all 8 dihedral
+symmetries.
+
+On-disk format is the TRM standard token layout (``seq_len = 81``, vocab 10).
+
+Usage:
+    python -m sheaf_admm.data.build_sudoku --output-dir datasets/sudoku_easy \
+        --train-size 50000 --test-size 2000 --difficulty-max 2.0
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections.abc import Iterable
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from .common import (
+    SUDOKU_VOCAB_SIZE,
+    PuzzleDatasetMetadata,
+    dihedral_transform,
+    save_npy,
+)
+
+
+@dataclass
+class SudokuConfig:
+    dataset: str = "Ritvik19/Sudoku-Dataset"
+    dataset_revision: str | None = None
+    height: int = 9
+    width: int = 9
+    seed: int = 0
+    train_size: int = 50000
+    test_size: int = 2000
+    difficulty_max: float = 2.0
+    train_augment: bool = True
+    test_augment: bool = False
+    output_dir: Path = Path("datasets/sudoku_easy")
+
+    def to_dict(self) -> dict:
+        payload = asdict(self)
+        payload["output_dir"] = str(self.output_dir)
+        return payload
+
+
+def _char_to_token(ch: str) -> int:
+    return 0 if ch == "." else int(ch)
+
+
+def parse_sudoku(text: str, height: int = 9, width: int = 9) -> np.ndarray:
+    """Parse an 81-char Sudoku string into a 9x9 int8 token grid."""
+    expected = height * width
+    if len(text) != expected:
+        raise ValueError(f"expected {expected} chars, got {len(text)}")
+    grid = np.zeros((height, width), dtype=np.int8)
+    for i, ch in enumerate(text):
+        r, c = divmod(i, width)
+        grid[r, c] = _char_to_token(ch)
+    return grid
+
+
+def _build_split_from_puzzles(
+    split: str,
+    puzzles: Iterable[tuple[np.ndarray, np.ndarray]],
+    cfg: SudokuConfig,
+    apply_augmentation: bool,
+) -> None:
+    """Write a split from an iterable of ``(input_grid, label_grid)`` 9x9 token pairs."""
+    output_root = cfg.output_dir / split
+    inputs: list[np.ndarray] = []
+    labels: list[np.ndarray] = []
+    puzzle_indices: list[int] = [0]
+    group_indices: list[int] = [0]
+    puzzle_identifiers: list[int] = []
+    total_examples = 0
+    num_puzzles = 0
+    aug_variants = list(range(8)) if apply_augmentation else [0]
+
+    for base_input, base_label in puzzles:
+        for k in aug_variants:
+            input_grid = base_input if k == 0 else dihedral_transform(base_input, k)
+            label_grid = base_label if k == 0 else dihedral_transform(base_label, k)
+            inputs.append(input_grid.astype(np.uint8).reshape(-1))
+            labels.append(label_grid.astype(np.uint8).reshape(-1))
+            total_examples += 1
+        num_puzzles += 1
+        puzzle_indices.append(total_examples)
+        group_indices.append(num_puzzles)
+        puzzle_identifiers.append(0)
+
+    inputs_arr = np.stack(inputs)
+    labels_arr = np.stack(labels)
+    save_npy(output_root / "all__inputs.npy", inputs_arr)
+    save_npy(output_root / "all__labels.npy", labels_arr)
+    save_npy(output_root / "all__puzzle_indices.npy", np.array(puzzle_indices, dtype=np.int32))
+    save_npy(output_root / "all__group_indices.npy", np.array(group_indices, dtype=np.int32))
+    save_npy(
+        output_root / "all__puzzle_identifiers.npy", np.array(puzzle_identifiers, dtype=np.int32)
+    )
+
+    metadata = PuzzleDatasetMetadata(
+        pad_id=0,
+        ignore_label_id=0,
+        blank_identifier_id=0,
+        vocab_size=SUDOKU_VOCAB_SIZE,
+        seq_len=cfg.height * cfg.width,
+        num_puzzle_identifiers=1,
+        total_groups=num_puzzles,
+        mean_puzzle_examples=total_examples / max(num_puzzles, 1),
+        total_puzzles=num_puzzles,
+        sets=["all"],
+        height=cfg.height,
+        width=cfg.width,
+    )
+    metadata.write(output_root / "dataset.json")
+    print(
+        json.dumps(
+            {
+                "split": split,
+                "examples": int(inputs_arr.shape[0]),
+                "puzzles": int(num_puzzles),
+                "augmented": apply_augmentation,
+            },
+            indent=2,
+        )
+    )
+
+
+def _stream_puzzles(
+    stream_iterator: Any, cfg: SudokuConfig, max_count: int
+) -> Iterable[tuple[np.ndarray, np.ndarray]]:
+    """Yield up to ``max_count`` parsed ``(input, label)`` grids passing the filter."""
+    found = 0
+    for example in stream_iterator:
+        if found >= max_count:
+            break
+        diff = example.get("difficulty")
+        try:
+            if diff is None or float(diff) > cfg.difficulty_max:
+                continue
+        except (ValueError, TypeError):
+            continue
+        yield (
+            parse_sudoku(example["puzzle"], cfg.height, cfg.width),
+            parse_sudoku(example["solution"], cfg.height, cfg.width),
+        )
+        found += 1
+
+
+def build(cfg: SudokuConfig) -> None:
+    """Stream the HF dataset and write the train / ``test_hard`` splits."""
+    try:
+        from datasets import load_dataset
+    except ImportError as exc:
+        raise ImportError("the 'datasets' library is required: pip install datasets") from exc
+
+    cfg.output_dir.mkdir(parents=True, exist_ok=True)
+    # Non-streaming: download once (~2.2 GB) then iterate the Arrow-backed split
+    # locally. HF streaming took tens of minutes for a few hundred puzzles here;
+    # this materializes in about a minute and then iterates instantly.
+    stream_iter = iter(load_dataset(cfg.dataset, split="train", revision=cfg.dataset_revision))
+
+    _build_split_from_puzzles(
+        "train", _stream_puzzles(stream_iter, cfg, cfg.train_size), cfg, cfg.train_augment
+    )
+    _build_split_from_puzzles(
+        "test_hard", _stream_puzzles(stream_iter, cfg, cfg.test_size), cfg, cfg.test_augment
+    )
+    (cfg.output_dir / "config.json").write_text(json.dumps(cfg.to_dict(), indent=2))
+    print(f"Done. Dataset saved to {cfg.output_dir}")
+
+
+def default_config() -> SudokuConfig:
+    return SudokuConfig()
+
+
+def parse_args() -> SudokuConfig:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output-dir", type=Path, default=SudokuConfig.output_dir)
+    parser.add_argument("--dataset-revision")
+    parser.add_argument("--train-size", type=int, default=SudokuConfig.train_size)
+    parser.add_argument("--test-size", type=int, default=SudokuConfig.test_size)
+    parser.add_argument("--difficulty-max", type=float, default=SudokuConfig.difficulty_max)
+    parser.add_argument("--no-train-augment", action="store_true")
+    parser.add_argument("--test-augment", action="store_true")
+    parser.add_argument("--seed", type=int, default=SudokuConfig.seed)
+    args = parser.parse_args()
+    return SudokuConfig(
+        output_dir=args.output_dir,
+        dataset_revision=args.dataset_revision,
+        train_size=args.train_size,
+        test_size=args.test_size,
+        difficulty_max=args.difficulty_max,
+        train_augment=not args.no_train_augment,
+        test_augment=args.test_augment,
+        seed=args.seed,
+    )
+
+
+if __name__ == "__main__":
+    build(parse_args())
diff --git a/src/sheaf_admm/data/common.py b/src/sheaf_admm/data/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..0486490a699bc7698187c5ee031a932b7fc39ce4
--- /dev/null
+++ b/src/sheaf_admm/data/common.py
@@ -0,0 +1,122 @@
+"""Framework-agnostic data primitives: tokens, dihedral symmetries, on-disk metadata.
+
+These are the pieces shared by the dataset builders and the on-disk format
+contract that the loaders validate against. Everything here is plain NumPy /
+dataclasses — no JAX — because it runs at dataset-build and disk-IO time.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+# Maze token convention. Inputs carry 1-4; labels add 5 (path). vocab_size = 6
+# (slot 0 is the pad/ignore id).
+TOKEN_IDS: Mapping[str, int] = {
+    "wall": 1,
+    "empty": 2,
+    "start": 3,
+    "goal": 4,
+    "path": 5,
+}
+
+# Sudoku token convention: '.' -> 0 (empty), '1'-'9' -> 1-9.
+SUDOKU_VOCAB_SIZE = 10
+
+# The 8 dihedral symmetries and their inverses (mirrors the TRM datasets).
+DIHEDRAL_INVERSE = [0, 3, 2, 1, 4, 5, 6, 7]
+
+
+def dihedral_transform(arr: np.ndarray, tid: int) -> np.ndarray:
+    """Apply the ``tid``-th dihedral symmetry (rotations, flips, diagonal mirrors)."""
+    if tid == 0:
+        return arr  # identity
+    if tid == 1:
+        return np.rot90(arr, k=1)
+    if tid == 2:
+        return np.rot90(arr, k=2)
+    if tid == 3:
+        return np.rot90(arr, k=3)
+    if tid == 4:
+        return np.fliplr(arr)  # horizontal flip
+    if tid == 5:
+        return np.flipud(arr)  # vertical flip
+    if tid == 6:
+        return arr.T  # main-diagonal reflection
+    if tid == 7:
+        return np.fliplr(np.rot90(arr, k=1))  # anti-diagonal reflection
+    raise ValueError(f"Unsupported dihedral transform index: {tid}")
+
+
+def inverse_dihedral_transform(arr: np.ndarray, tid: int) -> np.ndarray:
+    """Undo :func:`dihedral_transform`."""
+    return dihedral_transform(arr, DIHEDRAL_INVERSE[int(tid)])
+
+
+@dataclass
+class PuzzleDatasetMetadata:
+    """On-disk metadata for a TRM-style puzzle split (``dataset.json``).
+
+    Puzzle inputs and labels use one token per cell, so ``seq_len = H*W`` for
+    grid-shaped puzzle datasets.
+    """
+
+    pad_id: int
+    ignore_label_id: int | None
+    blank_identifier_id: int
+    vocab_size: int
+    seq_len: int
+    num_puzzle_identifiers: int
+    total_groups: int
+    mean_puzzle_examples: float
+    total_puzzles: int
+    sets: Sequence[str]
+    height: int | None = None
+    width: int | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), indent=2, sort_keys=True)
+
+    def write(self, path: Path) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(self.to_json())
+
+    @staticmethod
+    def from_json(path: Path) -> PuzzleDatasetMetadata:
+        payload = json.loads(Path(path).read_text())
+        # Older internal standard-token datasets carried these now-unused keys.
+        payload.pop("input_format", None)
+        payload.pop("num_input_channels", None)
+        return PuzzleDatasetMetadata(**payload)
+
+
+def save_npy(path: Path, array: np.ndarray) -> None:
+    """Save a ``.npy`` array, creating the parent directory if needed."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    np.save(path, array)
+
+
+def save_json(path: Path, payload: Mapping[str, Any]) -> None:
+    """Save a JSON payload, creating the parent directory if needed."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True))
+
+
+def shuffle_in_unison(rng: np.random.Generator, *arrays: np.ndarray) -> tuple[np.ndarray, ...]:
+    """Shuffle a set of arrays along axis 0 with one shared permutation."""
+    if not arrays:
+        return ()
+    length = arrays[0].shape[0]
+    for arr in arrays:
+        if arr.shape[0] != length:
+            raise ValueError("All arrays must share the same length on axis 0.")
+    perm = rng.permutation(length)
+    return tuple(arr[perm] for arr in arrays)
diff --git a/src/sheaf_admm/data/loaders.py b/src/sheaf_admm/data/loaders.py
new file mode 100644
index 0000000000000000000000000000000000000000..24620e1f455c1685aad3afaf819f265393ddeb3a
--- /dev/null
+++ b/src/sheaf_admm/data/loaders.py
@@ -0,0 +1,358 @@
+"""On-disk dataset loaders: memory-mapped, with format-contract validation.
+
+Two formats:
+
+* :class:`ImageDataset` — classification caches (MNIST). A split directory holds
+  ``images.npy`` + ``labels.npy``, and ``metadata.json`` carries per-split shapes
+  (so robustness splits with different padding/noise can coexist with the train
+  split, e.g. ``test_pad_16``).
+* :class:`PuzzleDataset` — TRM-style structured-prediction sets (maze, sudoku). A
+  split directory holds ``all__{inputs,labels,puzzle_indices,group_indices,
+  puzzle_identifiers}.npy`` + ``dataset.json``. Training samples by *group* (one
+  puzzle drawn per group, then rows within that puzzle); evaluation walks rows
+  sequentially.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+from .common import PuzzleDatasetMetadata
+
+# =============================================================================
+# Image datasets (classification)
+# =============================================================================
+
+
+class ImageDataset:
+    """Memory-mapped loader for cached image classification datasets (e.g. MNIST)."""
+
+    def __init__(self, dataset_dir: str | Path, split: str = "train") -> None:
+        self.dataset_dir = Path(dataset_dir)
+        self.split = split
+        self.metadata = json.loads((self.dataset_dir / "metadata.json").read_text())
+
+        split_dir = self.dataset_dir / split
+        self.images = np.load(split_dir / "images.npy", mmap_mode="r")
+        self.labels = np.load(split_dir / "labels.npy", mmap_mode="r")
+        self._validate()
+
+    def _validate(self) -> None:
+        if self.images.shape[0] != self.labels.shape[0]:
+            raise ValueError("images and labels must share the same length on axis 0")
+
+        # Prefer a per-split shape (robustness splits change H/W); fall back to global.
+        split_shapes = self.metadata.get("split_shapes", {})
+        expected_shape = split_shapes.get(self.split, self.metadata.get("image_shape"))
+        if expected_shape is not None:
+            expected_shape = tuple(expected_shape)
+            if tuple(self.images.shape[1:]) != expected_shape:
+                raise ValueError(
+                    f"image_shape mismatch for split {self.split!r}: "
+                    f"metadata {expected_shape}, observed {tuple(self.images.shape[1:])}"
+                )
+
+        expected_count = self.metadata.get("splits", {}).get(self.split)
+        if expected_count is not None and expected_count != self.images.shape[0]:
+            raise ValueError(
+                f"metadata count {expected_count} != observed {self.images.shape[0]} "
+                f"for split={self.split}"
+            )
+
+    @property
+    def num_examples(self) -> int:
+        return int(self.images.shape[0])
+
+    def iter_batches(
+        self,
+        batch_size: int,
+        shuffle: bool = False,
+        seed: int | None = None,
+        drop_last: bool = False,
+        rank: int = 0,
+        num_replicas: int = 1,
+    ) -> Iterator[Mapping[str, np.ndarray]]:
+        """Yield ``{"images", "labels"}`` batches, optionally sharded across replicas."""
+        if batch_size <= 0:
+            raise ValueError("batch_size must be positive")
+        if num_replicas <= 0:
+            raise ValueError("num_replicas must be positive")
+        if batch_size % num_replicas != 0:
+            raise ValueError("batch_size must be divisible by num_replicas")
+
+        indices = np.arange(self.num_examples, dtype=np.int64)
+        if shuffle:
+            np.random.default_rng(seed).shuffle(indices)
+
+        local_batch = batch_size // num_replicas
+        for start in range(0, self.num_examples, batch_size):
+            end = min(start + batch_size, self.num_examples)
+            if drop_last and end - start < batch_size:
+                break
+            local_start = rank * local_batch
+            local_end = min(local_start + local_batch, end - start)
+            if local_start >= end - start:
+                continue
+            batch_indices = indices[start:end][local_start:local_end]
+            yield {
+                "images": self.images[batch_indices],
+                "labels": self.labels[batch_indices],
+            }
+
+
+# =============================================================================
+# Puzzle datasets (structured prediction)
+# =============================================================================
+
+
+@dataclass
+class PuzzleSet:
+    """One named set within a split, with TRM cumulative-index bookkeeping."""
+
+    inputs: np.ndarray
+    labels: np.ndarray
+    puzzle_indices: np.ndarray  # [P+1] cumulative row offsets per puzzle
+    group_indices: np.ndarray  # [G+1] cumulative puzzle offsets per group
+    puzzle_identifiers: np.ndarray  # [P] identifier per puzzle
+
+    @property
+    def num_examples(self) -> int:
+        return int(self.inputs.shape[0])
+
+    @property
+    def num_puzzles(self) -> int:
+        return int(self.puzzle_indices.shape[0] - 1)
+
+    @property
+    def num_groups(self) -> int:
+        return int(self.group_indices.shape[0] - 1)
+
+    def validate(self, seq_len: int, label_seq_len: int | None = None) -> None:
+        if label_seq_len is None:
+            label_seq_len = seq_len
+            if self.inputs.shape != self.labels.shape:
+                raise ValueError("inputs and labels must share shape")
+        elif self.inputs.shape[0] != self.labels.shape[0]:
+            raise ValueError("inputs and labels must have the same batch size")
+        if self.inputs.ndim != 2:
+            raise ValueError(f"expected 2D inputs, got shape {self.inputs.shape}")
+        if self.inputs.shape[1] != seq_len:
+            raise ValueError(f"input seq_len {self.inputs.shape[1]} != expected {seq_len}")
+        if self.labels.shape[1] != label_seq_len:
+            raise ValueError(f"label seq_len {self.labels.shape[1]} != expected {label_seq_len}")
+
+        _validate_cumulative(self.puzzle_indices, self.num_examples, "puzzle_indices")
+        _validate_cumulative(self.group_indices, self.num_puzzles, "group_indices")
+        if self.puzzle_identifiers.shape != (self.num_puzzles,):
+            raise ValueError(
+                f"puzzle_identifiers shape {self.puzzle_identifiers.shape} "
+                f"!= num_puzzles {self.num_puzzles}"
+            )
+
+
+def _validate_cumulative(indices: np.ndarray, expected_last: int, name: str) -> None:
+    if indices.ndim != 1:
+        raise ValueError(f"{name} must be 1D, got shape {indices.shape}")
+    if not np.issubdtype(indices.dtype, np.integer):
+        raise ValueError(f"{name} must be integer typed, got {indices.dtype}")
+    if indices[0] != 0:
+        raise ValueError(f"{name} must start at 0, got {indices[0]}")
+    if np.any(np.diff(indices) < 0):
+        raise ValueError(f"{name} must be monotone nondecreasing")
+    if indices[-1] != expected_last:
+        raise ValueError(f"{name} last offset {indices[-1]} != expected {expected_last}")
+
+
+def _puzzle_ids_for_rows(puzzle_indices: np.ndarray, rows: np.ndarray) -> np.ndarray:
+    return np.searchsorted(puzzle_indices, rows, side="right") - 1
+
+
+def _sample_batch(
+    rng: np.random.Generator,
+    group_order: np.ndarray,
+    puzzle_indices: np.ndarray,
+    group_indices: np.ndarray,
+    start_index: int,
+    global_batch_size: int,
+) -> tuple[int, np.ndarray, np.ndarray]:
+    """Fill one global batch by walking ``group_order``: one random puzzle per group."""
+    batch_rows: list[np.ndarray] = []
+    batch_puzzle_ids: list[np.ndarray] = []
+    current_size = 0
+
+    while start_index < group_order.size and current_size < global_batch_size:
+        group_id = int(group_order[start_index])
+        start_index += 1
+        puzzle_id = int(rng.integers(group_indices[group_id], group_indices[group_id + 1]))
+        row_start = int(puzzle_indices[puzzle_id])
+        row_end = int(puzzle_indices[puzzle_id + 1])
+        puzzle_size = row_end - row_start
+        take = min(puzzle_size, global_batch_size - current_size)
+        if take > 0:
+            batch_rows.append(row_start + rng.choice(puzzle_size, take, replace=False))
+            batch_puzzle_ids.append(np.full(take, puzzle_id, dtype=np.int64))
+            current_size += take
+
+    if not batch_rows:
+        return start_index, np.zeros(0, dtype=np.int64), np.zeros(0, dtype=np.int64)
+    return start_index, np.concatenate(batch_rows), np.concatenate(batch_puzzle_ids)
+
+
+class PuzzleDataset:
+    """Memory-mapped loader for TRM-style puzzle datasets (maze, sudoku)."""
+
+    def __init__(self, dataset_dir: str | Path, split: str = "train") -> None:
+        self.dataset_dir = Path(dataset_dir)
+        self.split = split
+        self.metadata = PuzzleDatasetMetadata.from_json(self.dataset_dir / split / "dataset.json")
+        self.sets: dict[str, PuzzleSet] = {}
+        self._train_call = 0
+        self._load_sets()
+        self._validate_metadata_totals()
+
+    def _load_sets(self) -> None:
+        field_modes: Mapping[str, str | None] = {
+            "inputs": "r",
+            "labels": "r",
+            "puzzle_indices": None,
+            "group_indices": None,
+            "puzzle_identifiers": None,
+        }
+        split_dir = self.dataset_dir / self.split
+
+        for set_name in self.metadata.sets:
+            arrays = {
+                field: np.load(split_dir / f"{set_name}__{field}.npy", mmap_mode=mmap_mode)
+                for field, mmap_mode in field_modes.items()
+            }
+            puzzle_set = PuzzleSet(**arrays)
+            puzzle_set.validate(seq_len=self.metadata.seq_len)
+            self.sets[set_name] = puzzle_set
+
+    def _validate_metadata_totals(self) -> None:
+        total_puzzles = sum(s.num_puzzles for s in self.sets.values())
+        total_groups = sum(s.num_groups for s in self.sets.values())
+        total_examples = sum(s.num_examples for s in self.sets.values())
+
+        if total_puzzles != self.metadata.total_puzzles:
+            raise ValueError(
+                f"metadata.total_puzzles={self.metadata.total_puzzles} != observed {total_puzzles}"
+            )
+        if total_groups != self.metadata.total_groups:
+            raise ValueError(
+                f"metadata.total_groups={self.metadata.total_groups} != observed {total_groups}"
+            )
+        expected_mean = total_examples / max(total_puzzles, 1)
+        if not np.isclose(expected_mean, self.metadata.mean_puzzle_examples):
+            raise ValueError(
+                f"metadata.mean_puzzle_examples={self.metadata.mean_puzzle_examples} "
+                f"!= observed {expected_mean}"
+            )
+        for set_name, dataset in self.sets.items():
+            if dataset.puzzle_identifiers.size == 0:
+                continue
+            max_id = int(dataset.puzzle_identifiers.max())
+            if max_id >= self.metadata.num_puzzle_identifiers:
+                raise ValueError(
+                    f"{set_name} puzzle_identifier max {max_id} exceeds "
+                    f"metadata.num_puzzle_identifiers"
+                )
+
+    def _metadata_batch_fields(self) -> dict[str, int]:
+        out: dict[str, int] = {}
+        if self.metadata.height is not None:
+            out["height"] = int(self.metadata.height)
+        if self.metadata.width is not None:
+            out["width"] = int(self.metadata.width)
+        return out
+
+    def iter_test_batches(
+        self, batch_size: int, rank: int = 0, num_replicas: int = 1
+    ) -> Iterator[tuple[str, Mapping[str, np.ndarray]]]:
+        """Walk every set's rows sequentially, yielding ``(set_name, batch)``."""
+        if batch_size <= 0:
+            raise ValueError("batch_size must be positive")
+        if num_replicas <= 0:
+            raise ValueError("num_replicas must be positive")
+        if batch_size % num_replicas != 0:
+            raise ValueError("batch_size must be divisible by num_replicas")
+
+        local_batch = batch_size // num_replicas
+        for set_name, dataset in self.sets.items():
+            total = dataset.num_examples
+            for start in range(0, total, batch_size):
+                end = min(total, start + batch_size)
+                local_start = start + rank * local_batch
+                local_end = min(end, local_start + local_batch)
+                if local_start >= end:
+                    continue
+                rows = np.arange(local_start, local_end, dtype=np.int64)
+                puzzle_ids = _puzzle_ids_for_rows(dataset.puzzle_indices, rows)
+                yield (
+                    set_name,
+                    {
+                        "inputs": dataset.inputs[rows],
+                        "labels": dataset.labels[rows],
+                        "puzzle_ids": puzzle_ids.astype(np.int32),
+                        "puzzle_identifiers": dataset.puzzle_identifiers[puzzle_ids],
+                        **self._metadata_batch_fields(),
+                    },
+                )
+
+    def iter_train_batches(
+        self,
+        batch_size: int,
+        seed: int,
+        epochs_per_iter: int = 1,
+        rank: int = 0,
+        num_replicas: int = 1,
+    ) -> Iterator[tuple[str, Mapping[str, np.ndarray]]]:
+        """Group-sampled training batches: one random puzzle per group, full batches only."""
+        if batch_size <= 0:
+            raise ValueError("batch_size must be positive")
+        if epochs_per_iter < 1:
+            raise ValueError("epochs_per_iter must be >= 1")
+        if num_replicas <= 0:
+            raise ValueError("num_replicas must be positive")
+        if batch_size % num_replicas != 0:
+            raise ValueError("batch_size must be divisible by num_replicas")
+
+        self._train_call += 1
+        local_batch = batch_size // num_replicas
+        rng = np.random.default_rng(seed + self._train_call)
+
+        for set_name, dataset in self.sets.items():
+            group_order = np.concatenate(
+                [rng.permutation(dataset.num_groups) for _ in range(int(epochs_per_iter))]
+            )
+            start_index = 0
+            while start_index < group_order.size:
+                start_index, rows, puzzle_ids = _sample_batch(
+                    rng,
+                    group_order=group_order,
+                    puzzle_indices=dataset.puzzle_indices,
+                    group_indices=dataset.group_indices,
+                    start_index=start_index,
+                    global_batch_size=batch_size,
+                )
+                if rows.size < batch_size:
+                    break
+                keep = np.arange(rows.size, dtype=np.int64)[
+                    rank * local_batch : (rank + 1) * local_batch
+                ]
+                batch_rows, batch_puzzle_ids = rows[keep], puzzle_ids[keep]
+                yield (
+                    set_name,
+                    {
+                        "inputs": dataset.inputs[batch_rows],
+                        "labels": dataset.labels[batch_rows],
+                        "puzzle_ids": batch_puzzle_ids.astype(np.int32),
+                        "puzzle_identifiers": dataset.puzzle_identifiers[batch_puzzle_ids],
+                        **self._metadata_batch_fields(),
+                    },
+                )
diff --git a/src/sheaf_admm/data/views.py b/src/sheaf_admm/data/views.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b563c52c965dd885a1f2c7cd806f10c52e9ad4e
--- /dev/null
+++ b/src/sheaf_admm/data/views.py
@@ -0,0 +1,441 @@
+"""Views: the map between a global grid and the per-agent local representation.
+
+Two task families share this module:
+
+* **Grid tasks (maze / MNIST).** Agents sit on a regular grid of centers
+  (:func:`grid_agent_centers`), each owning a square ``patch_size`` patch
+  (:func:`patchify_batch_jax`). The agent graph is the grid adjacency
+  (:func:`build_grid_edge_indices`). After ADMM the per-agent logit patches are
+  stitched back to a global grid by averaging overlaps
+  (:func:`reassemble_logits`). Maze borders are handled by a wall-token pre-pad
+  *before* patch extraction (see :func:`prepare_maze_patches`), so boundary
+  agents see walls rather than zeros.
+
+* **Sudoku.** The 81 cells are covered by 27 constraint agents — 9 rows, 9
+  columns, 9 boxes — each a 9-cell view (:func:`sudoku_slice_batch_jax`). The
+  agent graph is the constraint multigraph (:func:`build_sudoku_multigraph`):
+  each cell is a 3-clique over its (row, col, box) agents, with per-edge
+  shared-cell slots. Reassembly averages the three views that cover each cell
+  (:func:`reassemble_sudoku_logits`).
+
+Tensor conventions: images are ``[B, H, W, C]``, agent patches are
+``[N, B, ph, pw, C]``, node states are ``[N, B, d_v]``, edges are ``[E, 2]``.
+"""
+
+from __future__ import annotations
+
+import functools
+import math
+from collections.abc import Sequence
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+# =============================================================================
+# Grid agents: centers, patches, edges
+# =============================================================================
+
+
+def grid_agent_centers(image_hw: Sequence[int], stride: int, patch_size: int) -> np.ndarray:
+    """Place agent centers on a regular grid.
+
+    The first center sits at ``patch_size // 2`` along each axis and centers
+    step by ``stride`` thereafter (``range(patch_size // 2, dim, stride)``).
+    Returns ``[N, 2]`` integer ``(y, x)`` coordinates in row-major order.
+    """
+    h, w = int(image_hw[0]), int(image_hw[1])
+    if stride <= 0:
+        raise ValueError("stride must be positive")
+    if patch_size <= 0:
+        raise ValueError("patch_size must be positive")
+
+    center = patch_size // 2
+    coords = [(y, x) for y in range(center, h, stride) for x in range(center, w, stride)]
+    return np.asarray(coords, dtype=np.int64)
+
+
+def patchify_batch_jax(
+    batch_images: jnp.ndarray, centers_yx: jnp.ndarray, patch_size: int
+) -> jnp.ndarray:
+    """Extract one ``patch_size`` patch per agent from each image.
+
+    ``batch_images``: ``[B, H, W, C]``; ``centers_yx``: ``[N, 2]`` integer
+    centers. The image is zero-padded by ``patch_size // 2`` on each spatial
+    side so every center yields a full patch. Returns ``[N, B, ps, ps, C]``.
+    """
+    images = jnp.asarray(batch_images)
+    centers = jnp.asarray(centers_yx, dtype=jnp.int32)
+    if images.ndim != 4:
+        raise ValueError(f"expected images of shape (B,H,W,C); got {images.shape}")
+    if centers.ndim != 2 or centers.shape[1] != 2:
+        raise ValueError("centers_yx must have shape (N, 2)")
+    if patch_size <= 0:
+        raise ValueError("patch_size must be positive")
+
+    pad = patch_size // 2
+    padded = jnp.pad(
+        images,
+        ((0, 0), (pad, pad), (pad, pad), (0, 0)),
+        mode="constant",
+        constant_values=0,
+    )
+    batch_size, channels = images.shape[0], images.shape[3]
+
+    def slice_center(center: jnp.ndarray) -> jnp.ndarray:
+        cy, cx = center[0], center[1]
+        # The pre-pad shifts the in-bounds origin to (cy, cx) on the padded grid.
+        return jax.lax.dynamic_slice(
+            padded, (0, cy, cx, 0), (batch_size, patch_size, patch_size, channels)
+        )
+
+    return jax.vmap(slice_center)(centers)
+
+
+def build_grid_edge_indices(centers: np.ndarray, stride: int, connectivity: int = 4) -> np.ndarray:
+    """Undirected grid edges between adjacent agent centers, each stored once.
+
+    Orientation is fixed so every pair appears a single time:
+
+    * 4-way: right, down.
+    * 8-way: right, down, down-right, down-left.
+
+    Returns ``[E, 2]`` int32 ``(u, v)`` indices into ``centers``.
+    """
+    if stride <= 0:
+        raise ValueError("stride must be positive")
+    if connectivity not in (4, 8):
+        raise ValueError("connectivity must be 4 or 8")
+    if centers.size == 0:
+        return np.zeros((0, 2), dtype=np.int32)
+
+    center_to_idx = {tuple(map(int, c)): i for i, c in enumerate(centers)}
+    offsets = [(0, stride), (stride, 0)]
+    if connectivity == 8:
+        offsets += [(stride, stride), (stride, -stride)]
+
+    edges = []
+    for i, (cy, cx) in enumerate(centers):
+        for dy, dx in offsets:
+            j = center_to_idx.get((int(cy + dy), int(cx + dx)))
+            if j is not None:
+                edges.append([i, j])
+
+    return np.asarray(edges, dtype=np.int32) if edges else np.zeros((0, 2), dtype=np.int32)
+
+
+def node_positions(centers: np.ndarray) -> jnp.ndarray:
+    """Float32 ``[N, 2]`` node positions for direction-indexed restriction maps."""
+    return jnp.asarray(centers, dtype=jnp.float32)
+
+
+# =============================================================================
+# Grid reassembly: stitch agent logit patches back to a global grid
+# =============================================================================
+
+
+def _overlap_slices(
+    center_yx: Sequence[int], patch_size: int, image_hw: tuple[int, int]
+) -> tuple[slice, slice, slice, slice]:
+    """In-bounds image slices and the matching local-patch slices for one agent."""
+    h, w = image_hw
+    pad = patch_size // 2
+    cy, cx = int(center_yx[0]), int(center_yx[1])
+    y0, x0 = cy - pad, cx - pad
+
+    y_start, x_start = max(y0, 0), max(x0, 0)
+    y_end, x_end = min(y0 + patch_size, h), min(x0 + patch_size, w)
+
+    py_start = y_start - y0
+    px_start = x_start - x0
+    return (
+        slice(y_start, y_end),
+        slice(x_start, x_end),
+        slice(py_start, py_start + (y_end - y_start)),
+        slice(px_start, px_start + (x_end - x_start)),
+    )
+
+
+def reassemble_logits(
+    patches: np.ndarray,
+    centers_yx: np.ndarray,
+    image_hw: Sequence[int],
+    num_classes: int,
+    mode: str = "mean",
+) -> np.ndarray:
+    """Stitch per-agent logit patches ``[N, B, ph, pw, C]`` into a global grid.
+
+    * ``"mean"``: average overlapping agent logits — ``logits_sum / max(counts, 1)``.
+    * ``"winner_conf"``: per pixel, keep the logits of the most confident agent
+      (max softmax probability).
+
+    Returns ``[B, H, W, num_classes]``.
+    """
+    patch_arr = np.asarray(patches)
+    centers = np.asarray(centers_yx)
+    if patch_arr.ndim != 5:
+        raise ValueError("patches must have shape (N, B, ph, pw, num_classes)")
+    if centers.ndim != 2 or centers.shape[0] != patch_arr.shape[0]:
+        raise ValueError("centers_yx must align with patches on the agent axis")
+    if patch_arr.shape[-1] != num_classes:
+        raise ValueError("num_classes must match the patch channel dimension")
+    mode = str(mode).lower()
+    if mode not in {"mean", "winner_conf"}:
+        raise ValueError(f"unknown reassembly mode {mode!r} (mean|winner_conf)")
+
+    num_agents, batch, ph, pw, _ = patch_arr.shape
+    h, w = int(image_hw[0]), int(image_hw[1])
+    if ph != pw:
+        raise ValueError("patches must be square")
+
+    if mode == "mean":
+        logits_sum = np.zeros((batch, h, w, num_classes), dtype=np.float32)
+        counts = np.zeros((batch, h, w, 1), dtype=np.float32)
+        for a in range(num_agents):
+            ys, xs, pys, pxs = _overlap_slices(centers[a], ph, (h, w))
+            if ys.start == ys.stop or xs.start == xs.stop:
+                continue
+            logits_sum[:, ys, xs, :] += patch_arr[a, :, pys, pxs, :]
+            counts[:, ys, xs, :] += 1.0
+        return logits_sum / np.maximum(counts, 1.0)
+
+    best_logits = np.zeros((batch, h, w, num_classes), dtype=np.float32)
+    best_conf = np.full((batch, h, w), -np.inf, dtype=np.float32)
+    for a in range(num_agents):
+        ys, xs, pys, pxs = _overlap_slices(centers[a], ph, (h, w))
+        if ys.start == ys.stop or xs.start == xs.stop:
+            continue
+        chunk = patch_arr[a, :, pys, pxs, :].astype(np.float32, copy=False)
+        probs = np.exp(chunk - np.max(chunk, axis=-1, keepdims=True))
+        probs /= np.maximum(np.sum(probs, axis=-1, keepdims=True), 1e-12)
+        conf = np.max(probs, axis=-1)  # [B, h', w']
+        cur = best_conf[:, ys, xs]
+        better = conf > cur
+        best_conf[:, ys, xs] = np.where(better, conf, cur)
+        best_logits[:, ys, xs, :] = np.where(better[..., None], chunk, best_logits[:, ys, xs, :])
+    return best_logits
+
+
+# =============================================================================
+# Label patches (per-agent supervision)
+# =============================================================================
+
+
+def extract_patch_jax(
+    image: jnp.ndarray, center_yx: jnp.ndarray, patch_size: int
+) -> tuple[jnp.ndarray, jnp.ndarray]:
+    """Extract a zero-padded patch and its validity mask around ``center_yx``.
+
+    ``image``: ``[H, W]`` or ``[H, W, C]``. Returns ``(patch, mask)`` where the
+    mask is 1.0 on real pixels and 0.0 on the zero-padding border.
+    """
+    pad = patch_size // 2
+    cy, cx = center_yx[0], center_yx[1]
+    multichannel = image.ndim == 3
+    h, w = image.shape[:2]
+
+    mask = jnp.ones((h, w), dtype=jnp.float32)
+    if multichannel:
+        image_padding = ((pad, pad), (pad, pad), (0, 0))
+        image_start = (cy, cx, 0)
+        image_size = (patch_size, patch_size, image.shape[2])
+    else:
+        image_padding = ((pad, pad), (pad, pad))
+        image_start = (cy, cx)
+        image_size = (patch_size, patch_size)
+
+    padded_image = jnp.pad(image, image_padding, mode="constant", constant_values=0)
+    padded_mask = jnp.pad(mask, ((pad, pad), (pad, pad)), mode="constant", constant_values=0)
+    patch = jax.lax.dynamic_slice(padded_image, image_start, image_size)
+    patch_mask = jax.lax.dynamic_slice(padded_mask, (cy, cx), (patch_size, patch_size))
+    return patch, patch_mask
+
+
+def get_agent_label_patches_jax(
+    labels: jnp.ndarray, centers: jnp.ndarray, patch_size: int
+) -> tuple[jnp.ndarray, jnp.ndarray]:
+    """Per-agent label patches for patch-local supervision.
+
+    ``labels``: ``[B, H, W]``; ``centers``: ``[N, 2]``. Returns
+    ``(label_patches, label_masks)`` both ``[N, B, ph, pw]``; overlapping pixels
+    are supervised once per covering agent.
+    """
+    vmapped = jax.vmap(
+        jax.vmap(extract_patch_jax, in_axes=(None, 0, None)),
+        in_axes=(0, None, None),
+    )
+    centers = jnp.asarray(centers, dtype=jnp.int32)
+    patches, masks = vmapped(labels, centers, patch_size)  # [B, N, ph, pw]
+    return jnp.transpose(patches, (1, 0, 2, 3)), jnp.transpose(masks, (1, 0, 2, 3))
+
+
+# =============================================================================
+# Sudoku views: 27-agent constraint slices and reassembly
+# =============================================================================
+
+
+def sudoku_slice_batch_jax(batch_grids: jnp.ndarray) -> jnp.ndarray:
+    """Slice a 9x9 grid into the 27 constraint-agent views.
+
+    ``batch_grids``: ``[B, 9, 9, C]``. Returns ``[B, 27, 9, C]`` where agents
+    0-8 are rows, 9-17 columns (transpose), 18-26 the 3x3 boxes (reshape
+    ``(3,3,3,3)`` then transpose ``(0,2,1,3)`` so each box flattens row-major).
+    """
+    grids = jnp.asarray(batch_grids)
+    if grids.ndim != 4:
+        raise ValueError(f"expected grids of shape (B,9,9,C); got {grids.shape}")
+    C = grids.shape[3]
+
+    def views_for(grid: jnp.ndarray) -> jnp.ndarray:
+        rows = grid
+        cols = jnp.transpose(grid, (1, 0, 2))
+        boxes = grid.reshape(3, 3, 3, 3, C).transpose(0, 2, 1, 3, 4).reshape(9, 9, C)
+        return jnp.concatenate([rows, cols, boxes], axis=0)
+
+    return jax.vmap(views_for)(grids)
+
+
+def reassemble_sudoku_logits(batch_logits: jnp.ndarray) -> jnp.ndarray:
+    """Average the three covering views back to a 9x9 grid.
+
+    ``batch_logits``: ``[B, 27, 9, C]``. Returns ``[B, 9, 9, C]``, the mean of
+    the row, column, and box reconstructions (inverse of
+    :func:`sudoku_slice_batch_jax`).
+    """
+    if batch_logits.ndim != 4:
+        raise ValueError(f"expected logits of shape (B,27,9,C); got {batch_logits.shape}")
+
+    def reconstruct(views: jnp.ndarray) -> jnp.ndarray:
+        C = views.shape[-1]
+        from_rows = views[0:9]
+        from_cols = jnp.transpose(views[9:18], (1, 0, 2))
+        from_boxes = views[18:27].reshape(3, 3, 3, 3, C).transpose(0, 2, 1, 3, 4).reshape(9, 9, C)
+        return (from_rows + from_cols + from_boxes) / 3.0
+
+    return jax.vmap(reconstruct)(batch_logits)
+
+
+def build_sudoku_multigraph(
+    grid_size: int = 9,
+) -> tuple[jnp.ndarray, jnp.ndarray, jnp.ndarray]:
+    """Build the Sudoku constraint multigraph over the 27 agents.
+
+    Each of the 81 cells is covered by exactly 3 agents (its row, column, box);
+    those 3 agents form a clique for that cell, giving 3 edges per cell. The
+    edge metadata records, per endpoint, *which* local 0-8 slot holds the shared
+    cell — used to select the per-slot restriction map / LoRA factor.
+
+    Returns ``(edge_indices [E, 2], map_u [E], map_v [E])`` with ``E = 243``.
+    """
+    global_ids = jnp.arange(grid_size * grid_size).reshape(1, grid_size, grid_size, 1)
+    slices = np.asarray(sudoku_slice_batch_jax(global_ids)[0, :, :, 0])  # [27, 9]
+
+    coverage: list[list[tuple[int, int]]] = [[] for _ in range(grid_size * grid_size)]
+    for agent_id in range(slices.shape[0]):
+        for local_idx in range(grid_size):
+            coverage[int(slices[agent_id, local_idx])].append((agent_id, local_idx))
+
+    edge_u, edge_v, map_u, map_v = [], [], [], []
+    for agents in coverage:
+        for i in range(len(agents)):
+            for j in range(i + 1, len(agents)):
+                (u, u_local), (v, v_local) = agents[i], agents[j]
+                edge_u.append(u)
+                edge_v.append(v)
+                map_u.append(u_local)
+                map_v.append(v_local)
+
+    edges = jnp.asarray(np.stack([edge_u, edge_v], axis=1), dtype=jnp.int32)
+    return edges, jnp.asarray(map_u, dtype=jnp.int32), jnp.asarray(map_v, dtype=jnp.int32)
+
+
+@functools.lru_cache(maxsize=1)
+def get_cached_sudoku_graph() -> tuple[jnp.ndarray, jnp.ndarray, jnp.ndarray]:
+    """Cached :func:`build_sudoku_multigraph` for the standard 9x9 board."""
+    return build_sudoku_multigraph(grid_size=9)
+
+
+def build_sudoku_cell_indices(grid_size: int = 9) -> jnp.ndarray:
+    """Global cell ids (0..80) seen by each agent: ``[27, 9]`` int32."""
+    global_ids = jnp.arange(grid_size * grid_size).reshape(1, grid_size, grid_size, 1)
+    return sudoku_slice_batch_jax(global_ids)[0, :, :, 0].astype(jnp.int32)
+
+
+def sudoku_num_nodes(grid_size: int = 9) -> int:
+    """Number of Sudoku constraint agents (= 3 * grid_size), derived not hardcoded."""
+    edges, _, _ = build_sudoku_multigraph(grid_size)
+    return int(np.asarray(edges).max()) + 1
+
+
+def sudoku_node_positions(num_nodes: int) -> jnp.ndarray:
+    """Principled ``head_valid`` node positions for the Sudoku agents.
+
+    Position ``(agent // 9, agent % 9)`` lays the 27 agents on a 3x9 grid. This
+    is only used to direction-index restriction maps; the Sudoku graph itself is
+    the constraint multigraph, so the exact coordinates are immaterial as long
+    as they are distinct. Do not reuse maze patch-grid centers here: distinct
+    Sudoku agents must keep distinct direction-index coordinates.
+    """
+    agent_ids = jnp.arange(num_nodes, dtype=jnp.int32)
+    return jnp.stack([agent_ids // 9, agent_ids % 9], axis=1).astype(jnp.float32)
+
+
+# =============================================================================
+# Maze wall-border pre-pad for boundary agents.
+# =============================================================================
+
+
+def prepare_maze_patches(
+    inputs_img: jnp.ndarray,
+    centers: jnp.ndarray,
+    patch_size: int,
+    num_input_classes: int,
+    *,
+    border_fill: float | None = None,
+) -> jnp.ndarray:
+    """Extract maze agent patches with a wall-token border pre-pad.
+
+    :func:`patchify_batch_jax` zero-pads internally; for mazes that would feed
+    boundary agents spurious zeros. We instead pad the image with a wall border
+    of width ``patch_size // 2`` *before* extraction (and shift centers), so
+    boundary patches see walls.
+
+    ``inputs_img`` is ``[B, H, W]`` int tokens; patches are one-hot
+    ``[N, B, ps, ps, num_input_classes]``. ``border_fill`` defaults to the wall
+    token (``TOKEN_IDS["wall"] = 1``).
+    """
+    from .common import TOKEN_IDS
+
+    inputs_img = jnp.asarray(inputs_img)
+    border = patch_size // 2
+    B = inputs_img.shape[0]
+    eH, eW = int(inputs_img.shape[1]), int(inputs_img.shape[2])
+    bH, bW = eH + 2 * border, eW + 2 * border
+    centers_bordered = jnp.asarray(centers, dtype=jnp.int32) + border
+
+    fill = float(TOKEN_IDS["wall"]) if border_fill is None else float(border_fill)
+    bordered = jnp.full((B, bH, bW), fill, dtype=inputs_img.dtype)
+    bordered = bordered.at[:, border : border + eH, border : border + eW].set(inputs_img)
+    onehot = jax.nn.one_hot(bordered, num_input_classes, dtype=jnp.float32)
+    return patchify_batch_jax(onehot, centers_bordered, patch_size)
+
+
+# =============================================================================
+# Misc
+# =============================================================================
+
+
+def infer_image_hw(
+    seq_len: int, height: int | None = None, width: int | None = None
+) -> tuple[int, int]:
+    """Resolve ``(H, W)`` from ``seq_len``; require both dims for non-square grids."""
+    if height is not None or width is not None:
+        if height is None or width is None:
+            raise ValueError("provide both height and width or neither")
+        if height * width != seq_len:
+            raise ValueError(f"dims {(height, width)} do not match seq_len={seq_len}")
+        return int(height), int(width)
+    root = int(math.isqrt(seq_len))
+    if root * root != seq_len:
+        raise ValueError("cannot infer non-square grid from seq_len; pass height/width")
+    return root, root
diff --git a/src/sheaf_admm/geometry/__init__.py b/src/sheaf_admm/geometry/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..45293e833fa513a1d54f215ffd47cb7068c6e7f7
--- /dev/null
+++ b/src/sheaf_admm/geometry/__init__.py
@@ -0,0 +1,41 @@
+"""Sheaf geometry: restriction maps, the sheaf Laplacian, and LoRA modulation."""
+
+from __future__ import annotations
+
+from .base import SheafGeometry
+from .fixed import FixedGeometry
+from .lora import LoRAGeometry, create_lora_geometry, create_sudoku_lora_geometry
+from .restriction_maps import (
+    DirectionalRestrictionMaps,
+    SharedRestrictionMap,
+    SudokuRestrictionMaps,
+    build_directional_restriction_maps,
+    build_shared_restriction_maps,
+    build_sudoku_restriction_maps,
+    compute_direction_index,
+    get_direction_names,
+    literal_sudoku_identity_maps,
+    make_rm_initializer,
+    make_sudoku_rm_initializer,
+    normalize_rm_sharing,
+)
+
+__all__ = [
+    "SheafGeometry",
+    "FixedGeometry",
+    "LoRAGeometry",
+    "create_lora_geometry",
+    "create_sudoku_lora_geometry",
+    "DirectionalRestrictionMaps",
+    "SharedRestrictionMap",
+    "SudokuRestrictionMaps",
+    "build_directional_restriction_maps",
+    "build_shared_restriction_maps",
+    "build_sudoku_restriction_maps",
+    "literal_sudoku_identity_maps",
+    "compute_direction_index",
+    "get_direction_names",
+    "make_rm_initializer",
+    "make_sudoku_rm_initializer",
+    "normalize_rm_sharing",
+]
diff --git a/src/sheaf_admm/geometry/base.py b/src/sheaf_admm/geometry/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..1df64cca809f3e77ffe078c8d11534a6dad37b04
--- /dev/null
+++ b/src/sheaf_admm/geometry/base.py
@@ -0,0 +1,59 @@
+"""The sheaf-geometry interface.
+
+A *geometry* bundles the cellular-sheaf structure used by the z-update: the
+agent graph (``edge_indices``), the restriction maps ``F_{i->e}`` (possibly
+input-modulated by LoRA), and the operators the consensus solvers need.
+
+The two operators that matter:
+
+* ``laplacian_apply`` — the sheaf Laplacian ``L_F = F^T F`` as a matrix-free,
+  block-sparse, per-edge matvec. Conjugate-gradient z-solvers call this.
+* ``energy`` — the sheaf energy ``E(z) = 1/2 sum_e ||F_{u->e} z_u - F_{v->e} z_v||^2``.
+  Gradient-descent z-solvers differentiate this.
+
+Everything operates on batched node states ``z`` of shape ``[N, B, d_v]`` (N
+agents, B batch, d_v vertex-stalk dim). Each batch element is an independent
+linear system; the Laplacian never mixes batch elements.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+import jax.numpy as jnp
+
+
+class SheafGeometry(Protocol):
+    """Interface for sheaf geometries (see module docstring).
+
+    Implementations: :class:`~sheaf_admm.geometry.fixed.FixedGeometry` (learned
+    but input-independent restriction maps) and
+    :class:`~sheaf_admm.geometry.lora.LoRAGeometry` (input-modulated maps
+    ``F = R + (alpha/r) A B^T``).
+    """
+
+    edge_indices: jnp.ndarray  # [E, 2] (u, v) node indices per edge
+    restriction_maps: jnp.ndarray  # [E, 2, d_e, d_v]; [:,0]=F_{u->e}, [:,1]=F_{v->e}
+
+    def edge_residuals(self, z: jnp.ndarray) -> jnp.ndarray:
+        """Coboundary ``F z``: per-edge disagreement ``F_{u->e} z_u - F_{v->e} z_v``.
+
+        ``z``: ``[N, B, d_v]`` -> ``r``: ``[E, B, d_e]``.
+        """
+        ...
+
+    def laplacian_apply(self, z: jnp.ndarray) -> jnp.ndarray:
+        """Sheaf Laplacian ``L_F z = F^T F z``. ``[N, B, d_v]`` -> ``[N, B, d_v]``."""
+        ...
+
+    def energy(self, z: jnp.ndarray) -> jnp.ndarray:
+        """Scalar sheaf energy ``1/2 sum_e ||F_{u->e} z_u - F_{v->e} z_v||^2``."""
+        ...
+
+    def consistency_rms(self, z: jnp.ndarray, eps: float = 1e-6) -> jnp.ndarray:
+        """Per-batch RMS disagreement ``sqrt(mean_{e,d_e} r^2 + eps)`` -> ``[B]``.
+
+        The ``+eps`` under the sqrt keeps the gradient finite at perfect
+        consensus (``r -> 0``), which is exactly the training target.
+        """
+        ...
diff --git a/src/sheaf_admm/geometry/fixed.py b/src/sheaf_admm/geometry/fixed.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e49498b24a9b06a25641f89af716d05bda369bd
--- /dev/null
+++ b/src/sheaf_admm/geometry/fixed.py
@@ -0,0 +1,52 @@
+"""Fixed geometry: learned but input-independent restriction maps."""
+
+from __future__ import annotations
+
+import jax.numpy as jnp
+from flax import struct
+
+
+@struct.dataclass
+class FixedGeometry:
+    """Sheaf geometry with restriction maps that do not depend on the input.
+
+    The maps in ``restriction_maps`` are learned parameters (built once per
+    forward pass from the shared base maps, see
+    :mod:`sheaf_admm.geometry.restriction_maps`) but are the same for every
+    batch element.
+    """
+
+    edge_indices: jnp.ndarray  # [E, 2]
+    restriction_maps: jnp.ndarray  # [E, 2, d_e, d_v]
+    edge_mask: jnp.ndarray | None = None  # [E] or [E,B] float mask
+
+    def edge_residuals(self, z: jnp.ndarray) -> jnp.ndarray:
+        u, v = self.edge_indices[:, 0], self.edge_indices[:, 1]
+        F_uv, F_vu = self.restriction_maps[:, 0], self.restriction_maps[:, 1]
+        Fz_u = jnp.einsum("eij,ebj->ebi", F_uv, z[u])
+        Fz_v = jnp.einsum("eij,ebj->ebi", F_vu, z[v])
+        r = Fz_u - Fz_v
+        if self.edge_mask is not None:
+            mask = self.edge_mask
+            mask = mask[:, None] if mask.ndim == 1 else mask
+            r = r * mask[:, :, None]
+        return r
+
+    def energy(self, z: jnp.ndarray) -> jnp.ndarray:
+        return 0.5 * jnp.sum(self.edge_residuals(z) ** 2)
+
+    def laplacian_apply(self, z: jnp.ndarray) -> jnp.ndarray:
+        r = self.edge_residuals(z)  # [E, B, d_e]
+        u, v = self.edge_indices[:, 0], self.edge_indices[:, 1]
+        F_uv, F_vu = self.restriction_maps[:, 0], self.restriction_maps[:, 1]
+        # F^T r, scattered back to the two endpoints (note the orientation sign on v).
+        contrib_u = jnp.einsum("eij,ebi->ebj", F_uv, r)
+        contrib_v = jnp.einsum("eij,ebi->ebj", F_vu, r)
+        out = jnp.zeros_like(z)
+        out = out.at[u].add(contrib_u)
+        out = out.at[v].add(-contrib_v)
+        return out
+
+    def consistency_rms(self, z: jnp.ndarray, eps: float = 1e-6) -> jnp.ndarray:
+        r = self.edge_residuals(z)
+        return jnp.sqrt(jnp.mean(r**2, axis=(0, 2)) + eps)
diff --git a/src/sheaf_admm/geometry/lora.py b/src/sheaf_admm/geometry/lora.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef31e88454cae340c89642cb651396e17b023156
--- /dev/null
+++ b/src/sheaf_admm/geometry/lora.py
@@ -0,0 +1,174 @@
+"""LoRA geometry: input-modulated restriction maps ``F = R + (alpha/r) A B^T``.
+
+The shared base map ``R`` is modulated per agent and per edge-direction by a
+low-rank update produced by the encoder. To keep the Laplacian matvec free of
+the expensive per-iteration multi-index gather, we precompute *edge-indexed*
+factors once at construction time (``create_lora_geometry`` /
+``create_sudoku_lora_geometry``): each edge already knows the A/B factors of its
+two endpoints in the relevant slot/direction. The matvec is then pure einsums.
+"""
+
+from __future__ import annotations
+
+import jax.numpy as jnp
+from flax import struct
+
+
+@struct.dataclass
+class LoRAGeometry:
+    """Sheaf geometry with per-agent LoRA-modulated restriction maps.
+
+    Effective edge map ``F = R + (alpha/r) A B^T``. The ``*_edge`` tensors are
+    the endpoints' A/B factors already gathered for each edge (see the
+    ``create_*`` factories below), so ``laplacian_apply`` is gather-free.
+    """
+
+    edge_indices: jnp.ndarray  # [E, 2]
+    restriction_maps: jnp.ndarray  # [E, 2, d_e, d_v] base maps R
+    lora_alpha: float
+    A_u_edge: jnp.ndarray  # [E, B, d_e, r]
+    A_v_edge: jnp.ndarray  # [E, B, d_e, r]
+    B_u_edge: jnp.ndarray  # [E, B, d_v, r]
+    B_v_edge: jnp.ndarray  # [E, B, d_v, r]
+    gate_u_edge: jnp.ndarray | None = None  # [E, B]
+    gate_v_edge: jnp.ndarray | None = None  # [E, B]
+    edge_mask: jnp.ndarray | None = None  # [E] or [E,B] float mask
+
+    @property
+    def _scale(self) -> float:
+        return self.lora_alpha / self.A_u_edge.shape[-1]
+
+    def _apply_endpoint(self, z_e, R, A_edge, B_edge, gate_edge):
+        """Effective map applied to one endpoint: ``(R + scale A B^T) z_e``."""
+        Rz = jnp.einsum("eij,ebj->ebi", R, z_e)  # [E, B, d_e]
+        Btz = jnp.einsum("ebjr,ebj->ebr", B_edge, z_e)  # [E, B, r]
+        ABtz = jnp.einsum("ebir,ebr->ebi", A_edge, Btz)  # [E, B, d_e]
+        if gate_edge is not None:
+            ABtz = ABtz * gate_edge[:, :, None]
+        return Rz + self._scale * ABtz
+
+    def _adjoint_endpoint(self, r, R, A_edge, B_edge, gate_edge):
+        """Adjoint of ``_apply_endpoint``: ``(R + scale A B^T)^T r``."""
+        contrib = jnp.einsum("eij,ebi->ebj", R, r)  # [E, B, d_v]
+        Atr = jnp.einsum("ebir,ebi->ebr", A_edge, r)  # [E, B, r]
+        if gate_edge is not None:
+            Atr = Atr * gate_edge[:, :, None]
+        lora = jnp.einsum("ebjr,ebr->ebj", B_edge, Atr)  # [E, B, d_v]
+        return contrib + self._scale * lora
+
+    def edge_residuals(self, z: jnp.ndarray) -> jnp.ndarray:
+        u, v = self.edge_indices[:, 0], self.edge_indices[:, 1]
+        Fz_u = self._apply_endpoint(
+            z[u], self.restriction_maps[:, 0], self.A_u_edge, self.B_u_edge, self.gate_u_edge
+        )
+        Fz_v = self._apply_endpoint(
+            z[v], self.restriction_maps[:, 1], self.A_v_edge, self.B_v_edge, self.gate_v_edge
+        )
+        r = Fz_u - Fz_v
+        if self.edge_mask is not None:
+            mask = self.edge_mask
+            mask = mask[:, None] if mask.ndim == 1 else mask
+            r = r * mask[:, :, None]
+        return r
+
+    def energy(self, z: jnp.ndarray) -> jnp.ndarray:
+        return 0.5 * jnp.sum(self.edge_residuals(z) ** 2)
+
+    def laplacian_apply(self, z: jnp.ndarray) -> jnp.ndarray:
+        r = self.edge_residuals(z)  # [E, B, d_e]
+        u, v = self.edge_indices[:, 0], self.edge_indices[:, 1]
+        contrib_u = self._adjoint_endpoint(
+            r, self.restriction_maps[:, 0], self.A_u_edge, self.B_u_edge, self.gate_u_edge
+        )
+        contrib_v = self._adjoint_endpoint(
+            r, self.restriction_maps[:, 1], self.A_v_edge, self.B_v_edge, self.gate_v_edge
+        )
+        out = jnp.zeros_like(z)
+        out = out.at[u].add(contrib_u)
+        out = out.at[v].add(-contrib_v)
+        return out
+
+    def consistency_rms(self, z: jnp.ndarray, eps: float = 1e-6) -> jnp.ndarray:
+        r = self.edge_residuals(z)
+        return jnp.sqrt(jnp.mean(r**2, axis=(0, 2)) + eps)
+
+
+def _gather_edge_factors(edge_indices, A, B, gate, sel_u, sel_v):
+    """Gather endpoint LoRA factors into edge-indexed tensors.
+
+    ``A``/``B``: ``[N, B, K, d_*, r]`` per-agent factors (K = directions or
+    cell-slots). ``sel_u``/``sel_v``: ``[E]`` slot index per endpoint.
+    """
+    u, v = edge_indices[:, 0], edge_indices[:, 1]
+    E = edge_indices.shape[0]
+    e = jnp.arange(E)
+    A_u_edge = A[u][e, :, sel_u]  # [E, B, d_e, r]
+    A_v_edge = A[v][e, :, sel_v]
+    B_u_edge = B[u][e, :, sel_u]
+    B_v_edge = B[v][e, :, sel_v]
+    gate_u_edge = gate_v_edge = None
+    if gate is not None:
+        gate_u_edge = gate[u][e, :, sel_u]  # [E, B]
+        gate_v_edge = gate[v][e, :, sel_v]
+    return A_u_edge, A_v_edge, B_u_edge, B_v_edge, gate_u_edge, gate_v_edge
+
+
+def create_lora_geometry(
+    edge_indices: jnp.ndarray,
+    node_positions: jnp.ndarray,
+    restriction_maps: jnp.ndarray,
+    A: jnp.ndarray,  # [N, B, K, d_e, r]
+    B: jnp.ndarray,  # [N, B, K, d_v, r]
+    lora_alpha: float,
+    num_directions: int,
+    gate: jnp.ndarray | None = None,  # [N, B, K]
+    edge_mask: jnp.ndarray | None = None,
+) -> LoRAGeometry:
+    """Directional (grid) LoRA geometry: select factors by edge direction."""
+    from .restriction_maps import compute_direction_index
+
+    u, v = edge_indices[:, 0], edge_indices[:, 1]
+    dy = node_positions[v, 0] - node_positions[u, 0]
+    dx = node_positions[v, 1] - node_positions[u, 1]
+    dir_uv = compute_direction_index(dy, dx, num_directions)
+    dir_vu = compute_direction_index(-dy, -dx, num_directions)
+    A_u, A_v, B_u, B_v, g_u, g_v = _gather_edge_factors(edge_indices, A, B, gate, dir_uv, dir_vu)
+    return LoRAGeometry(
+        edge_indices=edge_indices,
+        restriction_maps=restriction_maps,
+        lora_alpha=lora_alpha,
+        A_u_edge=A_u,
+        A_v_edge=A_v,
+        B_u_edge=B_u,
+        B_v_edge=B_v,
+        gate_u_edge=g_u,
+        gate_v_edge=g_v,
+        edge_mask=edge_mask,
+    )
+
+
+def create_sudoku_lora_geometry(
+    edge_indices: jnp.ndarray,
+    map_u: jnp.ndarray,  # [E] cell-slot 0-8
+    map_v: jnp.ndarray,  # [E] cell-slot 0-8
+    restriction_maps: jnp.ndarray,
+    A: jnp.ndarray,  # [N, B, 9, d_e, r]
+    B: jnp.ndarray,  # [N, B, 9, d_v, r]
+    lora_alpha: float,
+    gate: jnp.ndarray | None = None,
+    edge_mask: jnp.ndarray | None = None,
+) -> LoRAGeometry:
+    """Sudoku LoRA geometry: select factors by shared-cell slot (replaces direction)."""
+    A_u, A_v, B_u, B_v, g_u, g_v = _gather_edge_factors(edge_indices, A, B, gate, map_u, map_v)
+    return LoRAGeometry(
+        edge_indices=edge_indices,
+        restriction_maps=restriction_maps,
+        lora_alpha=lora_alpha,
+        A_u_edge=A_u,
+        A_v_edge=A_v,
+        B_u_edge=B_u,
+        B_v_edge=B_v,
+        gate_u_edge=g_u,
+        gate_v_edge=g_v,
+        edge_mask=edge_mask,
+    )
diff --git a/src/sheaf_admm/geometry/restriction_maps.py b/src/sheaf_admm/geometry/restriction_maps.py
new file mode 100644
index 0000000000000000000000000000000000000000..deb69993812f66d283ee23bd14737fbce64d8ffe
--- /dev/null
+++ b/src/sheaf_admm/geometry/restriction_maps.py
@@ -0,0 +1,250 @@
+"""Restriction-map construction: parameterization, initialization, and sharing.
+
+Restriction maps ``F_{i->e} in R^{d_e x d_v}`` project agent states into a
+shared edge stalk. Rather than learn one map per edge, we learn a small set of
+*base* maps and share them by edge type:
+
+* ``directional`` — one map per grid direction (N/E/S/W, or 8-way). Maze/MNIST.
+* ``shared`` — a single global map used on every edge. MNIST (global sharing).
+* ``sudoku`` — 9 maps, one per shared-cell slot; with ``soft_slice`` init each
+  is a selector onto one of 9 disjoint ``d_e``-blocks of the ``d_v``-stalk.
+
+These nn.Modules produce the base maps; the ``build_*`` functions gather them
+into the per-edge ``[E, 2, d_e, d_v]`` layout the geometries consume.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+import jax
+import jax.numpy as jnp
+from flax import linen as nn
+
+Initializer = Callable[[jax.Array, tuple[int, ...], jnp.dtype], jnp.ndarray]
+
+
+def get_direction_names(num_directions: int) -> tuple[str, ...]:
+    """Ordered direction names for 4-way or 8-way grid connectivity."""
+    if num_directions == 4:
+        return ("N", "E", "S", "W")
+    if num_directions == 8:
+        return ("N", "NE", "E", "SE", "S", "SW", "W", "NW")
+    raise ValueError("num_directions must be 4 or 8")
+
+
+def normalize_rm_sharing(rm_sharing: str) -> str:
+    """Canonicalize the ``rm_sharing`` string (``nesw`` is a legacy alias)."""
+    rm_sharing = rm_sharing.lower()
+    return "directional" if rm_sharing == "nesw" else rm_sharing
+
+
+def compute_direction_index(
+    dy: jnp.ndarray, dx: jnp.ndarray, num_directions: int = 4
+) -> jnp.ndarray:
+    """Map a position delta ``(dy, dx)`` to a direction index (JAX-traceable).
+
+    4-way: 0=N, 1=E, 2=S, 3=W (vertical takes priority).
+    8-way: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW.
+    """
+    if num_directions not in (4, 8):
+        raise ValueError("num_directions must be 4 or 8")
+    is_north, is_south = dy < 0, dy > 0
+    is_east, is_west = dx > 0, dx < 0
+    if num_directions == 4:
+        return jnp.where(is_north, 0, jnp.where(is_south, 2, jnp.where(is_east, 1, 3)))
+    return jnp.where(
+        is_north & is_east,
+        1,
+        jnp.where(
+            is_north & is_west,
+            7,
+            jnp.where(
+                is_north,
+                0,
+                jnp.where(
+                    is_south & is_east,
+                    3,
+                    jnp.where(
+                        is_south & is_west, 5, jnp.where(is_south, 4, jnp.where(is_east, 2, 6))
+                    ),
+                ),
+            ),
+        ),
+    )
+
+
+def make_rm_initializer(init_method: str, d_e: int, d_v: int) -> Initializer:
+    """Initializer for restriction maps of shape ``(d_e, d_v)`` or ``(E, 2, d_e, d_v)``.
+
+    ``orthonormal`` (default, paper) gives each map orthonormal rows; ``default``
+    is Glorot-normal; ``identity`` broadcasts ``eye(d_e, d_v)``.
+    """
+    if init_method == "orthonormal":
+        base_init = nn.initializers.orthogonal()
+    elif init_method == "default":
+        base_init = nn.initializers.glorot_normal()
+    elif init_method == "identity":
+
+        def init(key, shape, dtype=jnp.float32):
+            if shape[-2:] != (d_e, d_v):
+                raise ValueError(f"identity init expects trailing {(d_e, d_v)}, got {shape}")
+            return jnp.broadcast_to(jnp.eye(d_e, d_v, dtype=dtype), shape)
+
+        return init
+    else:
+        raise ValueError(f"unknown rm_init={init_method!r} (orthonormal|default|identity)")
+
+    def init(key, shape, dtype=jnp.float32):
+        if shape[-2:] != (d_e, d_v):
+            raise ValueError(f"rm init expects trailing {(d_e, d_v)}, got {shape}")
+        if len(shape) == 2:
+            return base_init(key, shape, dtype)
+        if len(shape) != 4:
+            raise ValueError(f"rm init expects (d_e,d_v) or (E,2,d_e,d_v), got {shape}")
+        keys = jax.random.split(key, shape[0] * shape[1])
+        mats = jax.vmap(lambda k: base_init(k, (d_e, d_v), dtype))(keys)
+        return mats.reshape(shape)
+
+    return init
+
+
+def make_sudoku_rm_initializer(init_method: str, d_e: int, d_v: int) -> Initializer:
+    """Initializer for the 9 Sudoku base maps, shape ``(9, d_e, d_v)``.
+
+    ``soft_slice`` (paper) seeds each map ``k`` as an identity selector onto the
+    k-th ``d_e``-block of the ``d_v``-stalk plus small noise — the inductive
+    bias that map ``k`` extracts cell ``k`` from an agent's 9-cell view. Requires
+    ``9 * d_e <= d_v`` (e.g. 9*32 = 288).
+    """
+    if init_method == "soft_slice":
+        if 9 * d_e > d_v:
+            raise ValueError(
+                f"soft_slice needs 9*d_e <= d_v (got 9*{d_e}={9 * d_e} > {d_v}); "
+                "the 9 selector blocks would not fit in the vertex stalk."
+            )
+
+        def init(key, shape, dtype=jnp.float32):
+            mats = nn.initializers.normal(stddev=0.01)(key, shape, dtype)
+            eye = jnp.eye(d_e, dtype=dtype)
+            for k in range(9):
+                mats = mats.at[k, :, k * d_e : (k + 1) * d_e].add(eye)
+            return mats
+
+        return init
+
+    if init_method == "orthonormal":
+        base_init = nn.initializers.orthogonal()
+    elif init_method == "default":
+        base_init = nn.initializers.glorot_normal()
+    elif init_method == "identity":
+
+        def init(key, shape, dtype=jnp.float32):
+            return jnp.broadcast_to(jnp.eye(d_e, d_v, dtype=dtype), shape)
+
+        return init
+    else:
+        raise ValueError(f"unknown sudoku rm_init={init_method!r}")
+
+    def init(key, shape, dtype=jnp.float32):
+        keys = jax.random.split(key, 9)
+        return jax.vmap(lambda k: base_init(k, (d_e, d_v), dtype))(keys)
+
+    return init
+
+
+class DirectionalRestrictionMaps(nn.Module):
+    """Learn one ``[d_e, d_v]`` base map per grid direction (4- or 8-way)."""
+
+    stalk_dim: int  # d_v
+    edge_stalk_dim: int | None = None  # d_e (defaults to d_v)
+    init_method: str = "orthonormal"
+    num_directions: int = 4
+
+    @nn.compact
+    def __call__(self) -> dict[str, jnp.ndarray]:
+        d_v = self.stalk_dim
+        d_e = self.edge_stalk_dim or self.stalk_dim
+        init = make_rm_initializer(self.init_method, d_e, d_v)
+        return {
+            name: self.param(f"R_{name}", init, (d_e, d_v))
+            for name in get_direction_names(self.num_directions)
+        }
+
+
+class SharedRestrictionMap(nn.Module):
+    """Learn a single ``[d_e, d_v]`` base map shared across all edges (global sharing)."""
+
+    stalk_dim: int  # d_v
+    edge_stalk_dim: int | None = None  # d_e
+    init_method: str = "orthonormal"
+
+    @nn.compact
+    def __call__(self) -> jnp.ndarray:
+        d_v = self.stalk_dim
+        d_e = self.edge_stalk_dim or self.stalk_dim
+        init = make_rm_initializer(self.init_method, d_e, d_v)
+        return self.param("R_shared", init, (d_e, d_v))
+
+
+class SudokuRestrictionMaps(nn.Module):
+    """Learn the 9 Sudoku base maps ``R_indices [9, d_e, d_v]`` (one per cell-slot)."""
+
+    stalk_dim: int  # d_v
+    edge_stalk_dim: int  # d_e
+    init_method: str = "soft_slice"
+
+    @nn.compact
+    def __call__(self) -> jnp.ndarray:
+        init = make_sudoku_rm_initializer(self.init_method, self.edge_stalk_dim, self.stalk_dim)
+        return self.param("R_indices", init, (9, self.edge_stalk_dim, self.stalk_dim))
+
+
+def build_directional_restriction_maps(
+    R_dict: dict[str, jnp.ndarray],
+    edge_indices: jnp.ndarray,
+    node_positions: jnp.ndarray,
+    num_directions: int = 4,
+) -> jnp.ndarray:
+    """Gather directional base maps into ``[E, 2, d_e, d_v]`` by edge direction."""
+    R_stack = jnp.stack([R_dict[n] for n in get_direction_names(num_directions)])  # [K,d_e,d_v]
+    u, v = edge_indices[:, 0], edge_indices[:, 1]
+    dy = node_positions[v, 0] - node_positions[u, 0]
+    dx = node_positions[v, 1] - node_positions[u, 1]
+    dir_uv = compute_direction_index(dy, dx, num_directions)
+    dir_vu = compute_direction_index(-dy, -dx, num_directions)
+    return jnp.stack([R_stack[dir_uv], R_stack[dir_vu]], axis=1)
+
+
+def build_shared_restriction_maps(R_shared: jnp.ndarray, num_edges: int) -> jnp.ndarray:
+    """Broadcast one base map onto all edges/endpoints -> ``[E, 2, d_e, d_v]``."""
+    return jnp.broadcast_to(R_shared[None, None], (num_edges, 2, *R_shared.shape))
+
+
+def build_sudoku_restriction_maps(
+    R_stack: jnp.ndarray, map_u: jnp.ndarray, map_v: jnp.ndarray
+) -> jnp.ndarray:
+    """Gather the 9 Sudoku base maps per edge by shared-cell slot -> ``[E, 2, d_e, d_v]``."""
+    return jnp.stack([R_stack[map_u], R_stack[map_v]], axis=1)
+
+
+def literal_sudoku_identity_maps(
+    d_e: int,
+    d_v: int,
+    map_u: jnp.ndarray,
+    map_v: jnp.ndarray,
+    *,
+    dtype=jnp.float32,
+) -> jnp.ndarray:
+    """Build the registered constant Sudoku intervention without parameters.
+
+    Every slot and endpoint receives the literal selector ``[I_d_e, 0, ...]``.
+    This function deliberately accepts no PRNG key and creates no Flax module,
+    so no restriction-map leaf can enter the parameter or optimizer trees.
+    """
+    if d_e <= 0 or d_v < d_e:
+        raise ValueError(f"constant identity requires 0 < d_e <= d_v, got {d_e}, {d_v}")
+    if map_u.shape != map_v.shape:
+        raise ValueError("map_u and map_v must have identical shapes")
+    base = jnp.eye(d_e, d_v, dtype=dtype)
+    return jnp.broadcast_to(base, (map_u.shape[0], 2, d_e, d_v))
diff --git a/src/sheaf_admm/models/__init__.py b/src/sheaf_admm/models/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca8663a29df9d7df68405015fba43924d92ce42f
--- /dev/null
+++ b/src/sheaf_admm/models/__init__.py
@@ -0,0 +1,62 @@
+"""Neural building blocks: shared layers, per-agent encoders/decoders, MPNN.
+
+The encoder maps each agent's local view to its consensus vector ``h`` and the
+local-objective parameters consumed by the x-solvers; the decoder maps final
+agent states back to logits. Both are **shared across agents** (the parent
+flattens the ``N`` agent axis into the batch). The MPNN module is the recurrent
+message-passing ablation of the ADMM coordinator and reuses the same
+encoder/decoder.
+"""
+
+from __future__ import annotations
+
+from .config import ModelConfig, model_config_from_dict
+from .decoder import (
+    ClassificationDecoder,
+    ConcatMLPDecoderV2,
+    SudokuDecoder,
+    create_decoder,
+)
+from .encoder import MLPEncoder, MLPEncoderV2, SudokuEncoder, create_encoder
+from .layers import (
+    CommHead,
+    GeLUMLP,
+    MLPBlock,
+    MLPMixerBlock,
+    RMSNorm,
+    SwiGLU,
+    rms_norm,
+)
+from .mpnn import DirectionalGGNN, DirectionalGGNNCell, GraphClassificationHead
+from .mpnn_model import MPNNModel
+from .sheaf_model import SheafADMMModel
+
+__all__ = [
+    # config + full models
+    "ModelConfig",
+    "model_config_from_dict",
+    "SheafADMMModel",
+    "MPNNModel",
+    # shared layers
+    "RMSNorm",
+    "rms_norm",
+    "MLPBlock",
+    "MLPMixerBlock",
+    "SwiGLU",
+    "GeLUMLP",
+    "CommHead",
+    # encoders
+    "MLPEncoder",
+    "MLPEncoderV2",
+    "SudokuEncoder",
+    "create_encoder",
+    # decoders
+    "ConcatMLPDecoderV2",
+    "SudokuDecoder",
+    "ClassificationDecoder",
+    "create_decoder",
+    # mpnn baseline
+    "DirectionalGGNN",
+    "DirectionalGGNNCell",
+    "GraphClassificationHead",
+]
diff --git a/src/sheaf_admm/models/config.py b/src/sheaf_admm/models/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cdb3b4de713b6850e1328a3ee907071b4bd1516
--- /dev/null
+++ b/src/sheaf_admm/models/config.py
@@ -0,0 +1,107 @@
+"""Model configuration.
+
+A single frozen dataclass holding every architectural / solver hyperparameter.
+It is hashable, so it can be a static field on a Flax module (no recompiles).
+The trainer builds it from the Hydra config via :func:`model_config_from_dict`.
+
+Field names follow the paper notation
+(``d_v``, ``d_e``, ``gamma``, ``cg_iters``, ``K_train``/``K_eval``, ...).
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any
+
+
+@dataclasses.dataclass(frozen=True)
+class ModelConfig:
+    # --- output ---
+    num_classes: int = 6  # per-agent output channels (grid: vocab; sudoku: 10; cls: #classes)
+
+    # --- stalk dims ---
+    d_v: int = 64  # vertex stalk (comm_dim)
+    d_e: int = 32  # edge stalk
+
+    # --- encoder ---
+    encoder_arch: str = "mlp_v2"  # "mlp_v2" (maze) | "mlp" (mnist) | "sudoku"
+    enc_hidden_dim: int = 256  # mlp_v2 hidden width
+    enc_d_model: int = 128  # sudoku token width
+    enc_num_blocks: int = 2  # sudoku mixer blocks
+    comm_norm_type: str = "layernorm"
+    dropout_rate: float = 0.0
+
+    # --- local objective (x-update) ---
+    objective_mode: str = "l1box_diag"  # simple|quadratic|lasso|non_negative|l1box_diag
+    x_solver: str = "diagonal_prox"  # simple|diagonal_prox (dense_quadratic is test/extension-only)
+    l1_weight: float = 0.0  # scalar L1 for objective_mode="lasso"
+    l1_init: float = 0.01  # per-dim L1 init for "l1box_diag"
+    upper_init: float = 1.0  # per-dim box upper init for "l1box_diag"
+    beta_init: float = 1.0  # tether stiffness for "simple"
+    q_epsilon: float = 1e-4
+
+    # --- consensus (z-update) ---
+    z_solver: str = "unrolled_cg"  # unrolled_cg | gd
+    z_mode: str = "prox"  # project (hard Fz=0) | prox (soft gamma)
+    gamma: float = 1.0  # soft-consensus weight (paper gamma)
+    cg_iters: int = 5  # T (unrolled CG steps)
+    tikhonov_eps: float = 1e-5  # project-mode L+eps*I
+    prox_init: str = "legacy"  # legacy | warm
+    gd_steps: int = 10  # GD inner diffusion steps
+    gd_momentum: float = 0.9
+
+    # --- restriction maps / geometry ---
+    rm_sharing: str = "directional"  # global | directional | sudoku
+    rm_init: str = "orthonormal"  # orthonormal | default | identity | soft_slice (sudoku)
+    rm_constant: bool = False  # literal non-parameter maps (registered Sudoku identity ablation)
+    rm_mode: str = "fixed"  # fixed | context (LoRA)
+    lora_rank: int = 4
+    lora_alpha: float = 1.0
+    lora_use_gate: bool = False
+    lora_init_style: str = "legacy"  # legacy (B=0) | standard (A=0)
+    num_directions: int = 4  # grid 4/8; sudoku LoRA uses 9
+
+    # --- ADMM penalty / step ---
+    rho_init: float = 0.1
+    rho_learnable: bool = True
+    eta_init: float = 0.01  # GD step size
+    eta_min: float | None = None  # bounded-log eta leash (with eta_max)
+    eta_max: float | None = None
+    eta_learnable: bool = True
+    relaxation_alpha: float = 1.0
+    z_init: str = "h"  # z^0 seed: "h" (encoder embedding, default) | "zeros" (Algorithm 1)
+
+    # --- recurrent-MPNN baseline (ignored by SheafADMMModel) ---
+    mpnn_message_dim: int | None = None  # message width (defaults to d_e)
+    mpnn_aggregation: str = "max"  # add | mean | symnorm | max
+    mpnn_edge_type_mode: str = "spatial"  # shared (1) | spatial (4/8) | slot (9, sudoku)
+    mpnn_graph_readout: str = "per_node"  # per_node (maze/sudoku) | graph (MNIST)
+
+    # --- decoder ---
+    decoder_arch: str = "mlp_concat_v2"  # mlp_concat_v2 | sudoku | classification
+    dec_hidden_dim: int = 256  # mlp_concat_v2
+    dec_hidden_dims: tuple[int, ...] = (128,)  # sudoku / classification
+    dec_linear_head: bool = False  # classification linear head (MNIST)
+    dec_readout_mode: str = "concat"  # classification: concat | x_only
+    dec_norm_type: str = "rmsnorm"
+
+
+def model_config_from_dict(d: dict[str, Any]) -> ModelConfig:
+    """Build a :class:`ModelConfig`, coercing list fields to tuples and dropping ``None`` overrides.
+
+    Unknown keys raise (no silent typos). Intended to be fed the merged
+    ``model`` + ``solver`` Hydra subtrees.
+    """
+    out = dict(d)
+    # Legacy checkpoints/configs may carry pre-public no-op fields. They never
+    # selected code paths in the public model, so ignore them on load.
+    for key in ("task", "mpnn_num_rounds"):
+        out.pop(key, None)
+    fields = {f.name for f in dataclasses.fields(ModelConfig)}
+    unknown = set(out) - fields
+    if unknown:
+        raise KeyError(f"unknown ModelConfig fields: {sorted(unknown)}")
+    for k in ("dec_hidden_dims",):
+        if k in out and out[k] is not None:
+            out[k] = tuple(out[k])
+    return ModelConfig(**out)
diff --git a/src/sheaf_admm/models/decoder.py b/src/sheaf_admm/models/decoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5bb3bda4876c5aaa66e70c1db252fa5facba0a5
--- /dev/null
+++ b/src/sheaf_admm/models/decoder.py
@@ -0,0 +1,146 @@
+"""Per-agent decoders: final agent state ``x`` (+ raw patch) -> logits.
+
+Like the encoder, decoders are **shared across agents**: the parent flattens
+``[N, B, d_v] -> [N*B, d_v]``, decodes once, and reshapes the logits back. So
+each module here takes a single leading batch axis ``B' = N*B``.
+
+Three decoders cover the paper tasks:
+
+* :class:`ConcatMLPDecoderV2` (``arch="mlp_concat_v2"``) — Maze and the MNIST
+  reconstruction path. A one-hidden-layer MLP over ``concat(flatten(patch), x)``,
+  reshaped to the output patch grid.
+* :class:`SudokuDecoder` (``arch="sudoku"``) — Sudoku. Reshapes ``[B', 288] ->
+  [B', 9, 32]``, runs shared MLP blocks over the 9 cells, and projects each to 10
+  digit logits.
+* :class:`ClassificationDecoder` (``arch="classification"``) — MNIST
+  classification. A linear or MLP head over ``x`` alone (``readout_mode="x_only"``,
+  the MNIST path) or ``concat([x, patch])``.
+
+All decoders share the ``(x, patches, *, training)`` call signature so the parent
+can dispatch them uniformly.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+from flax import linen as nn
+
+from .layers import MLPBlock, RMSNorm
+
+
+class ConcatMLPDecoderV2(nn.Module):
+    """Single-hidden-layer MLP decoder over ``concat(flatten(patch), x)``.
+
+    Architecture: ``RMSNorm(concat([flatten(patch), x])) -> Dense(hidden_dim) ->
+    GELU -> [Dropout] -> Dense(prod(output_shape))``, reshaped to ``output_shape``.
+    Maze (and the MNIST reconstruction path).
+    """
+
+    hidden_dim: int = 256
+    output_shape: tuple[int, ...] = (5, 5, 6)  # (H, W, C) or (H*W, C)
+    dropout_rate: float = 0.0
+
+    @nn.compact
+    def __call__(
+        self,
+        x: jnp.ndarray,  # [B', comm_dim] final agent state
+        patches: jnp.ndarray,  # [B', H, W, C] input patch
+        training: bool = True,
+    ) -> jnp.ndarray:
+        B = x.shape[0]
+        patch_flat = patches.reshape((B, -1))
+
+        h = jnp.concatenate([patch_flat, x], axis=-1)
+        h = RMSNorm(name="input_norm")(h)
+        h = nn.Dense(self.hidden_dim, name="dense")(h)
+        h = jax.nn.gelu(h)
+        if self.dropout_rate > 0:
+            h = nn.Dropout(rate=self.dropout_rate, deterministic=not training)(h)
+
+        out_size = int(np.prod(self.output_shape))
+        h = nn.Dense(out_size, name="output_dense")(h)
+        return h.reshape((B, *self.output_shape))
+
+
+class SudokuDecoder(nn.Module):
+    """Decode the consensus vector to per-cell digit logits (``arch="sudoku"``).
+
+    ``[B', 9*cell_dim] -> [B', 9, cell_dim]``, then shared :class:`MLPBlock` s over
+    the 9 cells (Flax applies Dense over the last axis, sharing across cells), then
+    ``Dense(output_channels)`` -> ``[B', 9, output_channels]``.
+    """
+
+    hidden_dims: Sequence[int] = (128,)
+    output_channels: int = 10
+    norm_type: str = "rmsnorm"
+
+    @nn.compact
+    def __call__(
+        self,
+        x: jnp.ndarray,  # [B', comm_dim]
+        patches: jnp.ndarray | None = None,
+        training: bool = True,
+    ) -> jnp.ndarray:
+        B = x.shape[0]
+        x = x.reshape(B, 9, -1)
+        for i, dim in enumerate(self.hidden_dims):
+            x = MLPBlock(out_dim=dim, norm_type=self.norm_type, name=f"block_{i}")(x)
+        return nn.Dense(self.output_channels, name="output_dense")(x)
+
+
+class ClassificationDecoder(nn.Module):
+    """Per-agent classification head (``arch="classification"``).
+
+    ``readout_mode`` selects the head input: ``x_only`` (the final agent state
+    alone — the MNIST path) or ``concat`` (``[x, flatten(patch)]``).
+    ``linear_head=True`` is a bare ``Dense(num_classes)``; otherwise the input runs
+    through ``Dense(hidden_dims[0])`` then :class:`MLPBlock` s before the output.
+    """
+
+    hidden_dims: Sequence[int] = (128,)
+    output_channels: int = 10
+    norm_type: str = "rmsnorm"
+    linear_head: bool = False
+    readout_mode: str = "concat"  # "concat" | "x_only"
+
+    @nn.compact
+    def __call__(
+        self,
+        x: jnp.ndarray,  # [B', comm_dim]
+        patches: jnp.ndarray,  # [B', H, W, C]
+        training: bool = True,
+    ) -> jnp.ndarray:
+        B = x.shape[0]
+        if self.readout_mode == "concat":
+            readout = jnp.concatenate([x, patches.reshape((B, -1))], axis=-1)
+        elif self.readout_mode == "x_only":
+            readout = x
+        else:
+            raise ValueError(f"unknown readout_mode={self.readout_mode!r} (concat|x_only)")
+
+        if self.linear_head:
+            return nn.Dense(features=self.output_channels, name="cls_output")(readout)
+
+        h = nn.Dense(self.hidden_dims[0], name="input_proj")(readout)
+        for i, dim in enumerate(self.hidden_dims):
+            h = MLPBlock(out_dim=dim, norm_type=self.norm_type, name=f"block_{i}")(h)
+        return nn.Dense(features=self.output_channels, name="cls_output")(h)
+
+
+def create_decoder(arch: str = "mlp_concat_v2", **kwargs) -> nn.Module:
+    """Build a decoder module by name.
+
+    ``arch`` in ``{"mlp_concat_v2", "sudoku", "classification"}``. Unknown kwargs
+    for the chosen arch raise (no silent drops).
+    """
+    if arch == "mlp_concat_v2":
+        return ConcatMLPDecoderV2(**kwargs)
+    if arch == "sudoku":
+        return SudokuDecoder(**kwargs)
+    if arch == "classification":
+        return ClassificationDecoder(**kwargs)
+    raise ValueError(f"unknown decoder arch={arch!r} (mlp_concat_v2|sudoku|classification)")
diff --git a/src/sheaf_admm/models/encoder.py b/src/sheaf_admm/models/encoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..28f59fdc307d1cd07e8b795eb08ddeec0e166294
--- /dev/null
+++ b/src/sheaf_admm/models/encoder.py
@@ -0,0 +1,484 @@
+"""Per-agent encoders: patch -> consensus vector ``h`` + local-objective params.
+
+The encoder is the only learned map from raw local views to the convex
+subproblem each agent solves. It is **shared across agents**: the parent model
+flattens the agent and batch axes (``[N, B, ...] -> [N*B, ...]``), applies the
+encoder once, and reshapes the outputs back to ``[N, B, ...]``. So every module
+here operates on a single leading batch axis ``B' = N*B``; the ``[N, B, ...]``
+contract in the solvers is the parent's responsibility.
+
+Three architectures cover the tasks:
+
+* :class:`MLPEncoderV2` (``arch="mlp_v2"``) — Maze. A one-hidden-layer MLP over
+  the flattened patch.
+* :class:`MLPEncoder` (``arch="mlp"``) — MNIST. A residual-MLP over the patch.
+* :class:`SudokuEncoder` (``arch="sudoku"``) — Sudoku. An MLP-Mixer over the 9
+  cells of an agent's row/col/box view, with a per-cell projection that lays out
+  the 9 cell embeddings contiguously in the ``comm_dim`` stalk.
+
+Objective heads (see :mod:`sheaf_admm.solvers.x_solvers`) turn the encoder
+features into the local-objective parameters. The diagonal curvature is emitted
+as a ``q_diag`` **vector** ``[B', d]`` (not a dense ``[B', d, d]`` matrix),
+matching the unified ``diagonal_prox`` x-solver.
+
+Emitted ``encoder_output`` keys by ``objective_mode``:
+
+* ``simple``: ``h``, ``beta`` (scalar learned tether stiffness).
+* ``quadratic``: ``h``, ``q_diag``, ``q``.
+* ``lasso`` (MNIST): ``h``, ``q_diag``, ``q``, ``l1_weight`` (scalar config).
+* ``non_negative`` (Sudoku): ``h``, ``q_diag``, ``q``, ``lower=0``.
+* ``l1box_diag`` (Maze): ``h``, ``q_diag``, ``q``, ``l1_weight`` (per-dim),
+  ``upper`` (per-dim), ``lower=0``.
+
+LoRA modulation (``rm_mode="context"``) additionally emits ``A`` ``[B',K,d_e,r]``,
+``B`` ``[B',K,d_v,r]`` (legacy init: ``A=lecun_normal``, ``B=zeros`` so the
+initial ``A B^T = 0``), and an optional ``gate`` ``[B',K]``. These feed
+``create_lora_geometry`` / ``create_sudoku_lora_geometry`` after the parent
+reshapes them to ``[N, B, K, ...]``. ``K`` is the number of grid directions
+(4/8) or 9 (Sudoku cell-slots).
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import jax
+import jax.numpy as jnp
+from flax import linen as nn
+
+from sheaf_admm.admm import inverse_softplus
+
+from .layers import CommHead, MLPBlock, MLPMixerBlock, RMSNorm
+
+
+def _use_standard_lora_init(init_style: str) -> bool:
+    """``legacy`` (A=random, B=0) vs ``standard`` (A=0, B=random, Hu et al. 2021)."""
+    style = (init_style or "").lower()
+    if style not in ("legacy", "standard"):
+        raise ValueError(f"unknown lora_init_style={init_style!r} (legacy|standard)")
+    return style == "standard"
+
+
+# ---------------------------------------------------------------------------
+# Objective heads: encoder features -> local-objective parameters.
+# Each takes pooled/flattened features [B', feat] and emits a parameter tensor.
+# ---------------------------------------------------------------------------
+
+
+def diag_curvature(
+    x: jnp.ndarray, comm_dim: int, q_epsilon: float, softplus: bool, name: str
+) -> jnp.ndarray:
+    """Per-coordinate curvature ``q_diag`` ``[B', d]``, strictly positive.
+
+    ``softplus(raw) + q_epsilon`` (default) keeps ``Q`` PSD; ``softplus=False``
+    allows negative diagonals (only ``Q + rho I`` needs to be PSD).
+    """
+    raw = nn.Dense(comm_dim, name=name)(x)
+    return (jax.nn.softplus(raw) if softplus else raw) + q_epsilon
+
+
+def linear_term(x: jnp.ndarray, comm_dim: int, name: str) -> jnp.ndarray:
+    """Linear objective term ``q`` ``[B', d]`` (the paper uses a dense vector)."""
+    return nn.Dense(comm_dim, name=name)(x)
+
+
+def softplus_head(x: jnp.ndarray, out_dim: int, init_value: float, name: str) -> jnp.ndarray:
+    """Positive per-dim head ``softplus(Dense(x))`` with bias seeded to ``init_value``.
+
+    Kernel is zero-init so the output starts uniformly at ``init_value``
+    (``softplus(inverse_softplus(init_value)) = init_value``). Used for per-dim
+    L1 weights (init 0.01) and box upper bounds (init 1.0).
+    """
+    raw = nn.Dense(
+        out_dim,
+        kernel_init=nn.initializers.zeros,
+        bias_init=nn.initializers.constant(inverse_softplus(init_value)),
+        name=name,
+    )(x)
+    return jax.nn.softplus(raw)
+
+
+def emit_lora_factors(
+    x: jnp.ndarray,
+    *,
+    num_slots: int,
+    d_e: int,
+    d_v: int,
+    rank: int,
+    init_style: str,
+    use_gate: bool,
+) -> dict[str, jnp.ndarray]:
+    """LoRA factors for restriction-map modulation ``F = R + (alpha/r) A B^T``.
+
+    ``A`` ``[B', K, d_e, r]`` up-projects into edge space; ``B`` ``[B', K, d_v, r]``
+    down-projects from vertex space. Legacy init (``B=0``) gives initial
+    ``A B^T = 0`` so training starts from the fixed base maps. ``x`` should be the
+    LoRA-prenorm features; ``K = num_slots`` (grid directions or Sudoku slots).
+    """
+    B = x.shape[0]
+    use_standard = _use_standard_lora_init(init_style)
+    zero_init = nn.initializers.zeros
+    default_init = nn.initializers.lecun_normal()
+
+    A_flat = nn.Dense(
+        num_slots * d_e * rank,
+        kernel_init=zero_init if use_standard else default_init,
+        name="lora_A_dense",
+    )(x)
+    B_flat = nn.Dense(
+        num_slots * d_v * rank,
+        kernel_init=default_init if use_standard else zero_init,
+        name="lora_B_dense",
+    )(x)
+    out = {
+        "A": A_flat.reshape((B, num_slots, d_e, rank)),
+        "B": B_flat.reshape((B, num_slots, d_v, rank)),
+    }
+    if use_gate:
+        gate_logits = nn.Dense(
+            num_slots, bias_init=nn.initializers.constant(-2.0), name="lora_gate_dense"
+        )(x)
+        out["gate"] = jax.nn.sigmoid(gate_logits)
+    return out
+
+
+class _ObjectiveHeads(nn.Module):
+    """Objective heads shared by both encoders (a submodule so heads own params).
+
+    Reads pooled/flattened features and emits the local-objective parameters for
+    the chosen ``objective_mode``; the ``simple`` mode emits a single learned
+    scalar tether stiffness ``beta = softplus(beta_raw)``. See the module
+    docstring for the key contract.
+    """
+
+    objective_mode: str
+    comm_dim: int
+    q_epsilon: float = 1e-4
+    q_diag_softplus: bool = True
+    l1_weight: float = 0.0
+    l1_init: float = 0.01
+    upper_init: float = 1.0
+    beta_init: float = 1.0
+
+    @nn.compact
+    def __call__(self, h: jnp.ndarray, feats: jnp.ndarray) -> dict[str, Any]:
+        out: dict[str, Any] = {"h": h}
+
+        if self.objective_mode == "simple":
+            beta_raw = self.param(
+                "beta_raw",
+                lambda k, s, d=jnp.float32: jnp.full(s, inverse_softplus(self.beta_init), d),
+                (),
+            )
+            out["beta"] = jax.nn.softplus(beta_raw)
+            return out
+
+        if self.objective_mode in ("quadratic", "lasso", "non_negative", "l1box_diag"):
+            out["q_diag"] = diag_curvature(
+                feats, self.comm_dim, self.q_epsilon, self.q_diag_softplus, "q_diag_dense"
+            )
+            out["q"] = linear_term(feats, self.comm_dim, "q_dense")
+        else:
+            raise ValueError(
+                f"unknown objective_mode={self.objective_mode!r} "
+                "(simple|quadratic|lasso|non_negative|l1box_diag)"
+            )
+
+        if self.objective_mode == "lasso":
+            # Scalar L1 weight from config (MNIST); no per-dim head.
+            out["l1_weight"] = jnp.asarray(self.l1_weight, dtype=feats.dtype)
+        elif self.objective_mode == "non_negative":
+            out["lower"] = 0.0
+        elif self.objective_mode == "l1box_diag":
+            out["l1_weight"] = softplus_head(feats, self.comm_dim, self.l1_init, "l1_weight_dense")
+            out["upper"] = softplus_head(feats, self.comm_dim, self.upper_init, "upper_bound_dense")
+            out["lower"] = 0.0
+        return out
+
+
+class MLPEncoderV2(nn.Module):
+    """Single-hidden-layer MLP encoder (``arch="mlp_v2"``). Maze + MNIST.
+
+    Architecture: ``flatten -> RMSNorm -> Dense(hidden_dim) -> GELU -> [Dropout]
+    -> CommHead(comm_dim)``, then objective and (optional) LoRA heads.
+    """
+
+    hidden_dim: int = 256
+    comm_dim: int = 64
+    edge_stalk_dim: int | None = None
+    comm_norm_type: str = "layernorm_zeros"
+    dropout_rate: float = 0.0
+
+    objective_mode: str = "simple"
+    q_epsilon: float = 1e-4
+    q_diag_softplus: bool = True
+    l1_weight: float = 0.0  # scalar L1 weight for objective_mode="lasso"
+    l1_init: float = 0.01  # per-dim L1 init for objective_mode="l1box_diag"
+    upper_init: float = 1.0  # per-dim box upper-bound init for "l1box_diag"
+    beta_init: float = 1.0  # tether stiffness init for objective_mode="simple"
+
+    rm_mode: str = "fixed"  # "fixed" | "context" (LoRA)
+    lora_rank: int = 4
+    lora_use_gate: bool = False
+    lora_init_style: str = "legacy"
+    num_directions: int = 4
+
+    @nn.compact
+    def __call__(self, x: jnp.ndarray, training: bool = True) -> dict[str, Any]:
+        """Encode patches ``[B', H, W, C]`` -> ``encoder_output`` dict (see module doc)."""
+        B = x.shape[0]
+        x = x.reshape((B, -1))
+        x = RMSNorm(name="input_norm")(x)
+        x = nn.Dense(self.hidden_dim, name="dense")(x)
+        x = jax.nn.gelu(x)
+        if self.dropout_rate > 0:
+            x = nn.Dropout(rate=self.dropout_rate, deterministic=not training)(x)
+
+        h = CommHead(
+            communication_dim=self.comm_dim,
+            comm_norm_type=self.comm_norm_type,
+            name="comm_head",
+        )(x)
+
+        output = _ObjectiveHeads(
+            objective_mode=self.objective_mode,
+            comm_dim=self.comm_dim,
+            q_epsilon=self.q_epsilon,
+            q_diag_softplus=self.q_diag_softplus,
+            l1_weight=self.l1_weight,
+            l1_init=self.l1_init,
+            upper_init=self.upper_init,
+            beta_init=self.beta_init,
+            name="objective_heads",
+        )(h, x)
+
+        if self.rm_mode == "context":
+            d_e = self.edge_stalk_dim if self.edge_stalk_dim is not None else self.comm_dim
+            x_lora = nn.LayerNorm(name="lora_pre_ln")(x)
+            output.update(
+                emit_lora_factors(
+                    x_lora,
+                    num_slots=self.num_directions,
+                    d_e=d_e,
+                    d_v=self.comm_dim,
+                    rank=self.lora_rank,
+                    init_style=self.lora_init_style,
+                    use_gate=self.lora_use_gate,
+                )
+            )
+        return output
+
+
+class SudokuEncoder(nn.Module):
+    """MLP-Mixer encoder over the 9 cells of an agent's view (``arch="sudoku"``).
+
+    Architecture: token embed (std ``1/sqrt(d_model)``) + optional global
+    cell-position ``Embed(81)`` + learned relative position, scaled by
+    ``sqrt(d_model)/sqrt(2)``; ``num_blocks`` mixer blocks (``mlp_ratio=2``,
+    SwiGLU); RMSNorm; per-cell shared ``Dense(comm_dim//9)``; RMSNorm; flatten the
+    9 cell blocks contiguously into ``[B', comm_dim]`` (requires ``comm_dim % 9 ==
+    0``); CommHead. With ``comm_dim=288`` each cell occupies 32 dims.
+
+    The objective/LoRA heads read the mean-pooled post-mixer tokens ``x_pooled``.
+    LoRA ``K = num_directions`` (set to 9 for Sudoku cell-slots).
+    """
+
+    d_model: int = 128
+    num_blocks: int = 2
+    mlp_ratio: float = 2.0
+    mlp_type: str = "swiglu"
+    comm_dim: int = 288
+    edge_stalk_dim: int | None = None
+    comm_norm_type: str = "layernorm_zeros"
+
+    objective_mode: str = "simple"
+    q_epsilon: float = 1e-4
+    q_diag_softplus: bool = True
+    l1_weight: float = 0.0
+    l1_init: float = 0.01
+    upper_init: float = 1.0
+    beta_init: float = 1.0
+
+    rm_mode: str = "fixed"
+    lora_rank: int = 4
+    lora_use_gate: bool = False
+    lora_init_style: str = "legacy"
+    num_directions: int = 4
+
+    @nn.compact
+    def __call__(self, x: jnp.ndarray, cell_ids: jnp.ndarray | None = None) -> dict[str, Any]:
+        """Encode cell views ``[B', 9, 10]`` -> ``encoder_output`` dict.
+
+        ``cell_ids`` ``[B', 9]`` (optional) are global board-cell indices 0..80 for
+        the absolute-position ``Embed(81)``.
+        """
+        B, T, _ = x.shape
+        embed_scale = math.sqrt(self.d_model)
+
+        x_embed = nn.Dense(
+            self.d_model,
+            kernel_init=nn.initializers.normal(stddev=1.0 / embed_scale),
+            name="token_embed",
+        )(x)
+
+        if cell_ids is not None:
+            x_embed = x_embed + nn.Embed(
+                num_embeddings=81,
+                features=self.d_model,
+                embedding_init=nn.initializers.normal(stddev=1.0 / embed_scale),
+                name="global_pos_embed",
+            )(cell_ids)
+
+        pos_embed = self.param(
+            "pos_embed",
+            nn.initializers.normal(stddev=1.0 / embed_scale),
+            (1, T, self.d_model),
+        )
+        x_embed = (x_embed + pos_embed) * (embed_scale / math.sqrt(2))
+
+        token_mlp_dim = int(T * self.mlp_ratio)
+        channel_mlp_dim = int(self.d_model * self.mlp_ratio)
+        y = x_embed
+        for i in range(self.num_blocks):
+            y = MLPMixerBlock(
+                token_mlp_dim=token_mlp_dim,
+                channel_mlp_dim=channel_mlp_dim,
+                mlp_type=self.mlp_type,
+                name=f"mixer_block_{i}",
+            )(y)
+        y = RMSNorm(name="pre_flat_norm")(y)
+
+        if self.comm_dim % 9 != 0:
+            raise ValueError(f"comm_dim must be divisible by 9, got {self.comm_dim}")
+        cell_dim = self.comm_dim // 9
+
+        # Per-cell projection shared across the 9 tokens, then RMSNorm, then a
+        # contiguous flatten so cell k occupies stalk block [k*cell_dim, ...].
+        y_cells = nn.Dense(cell_dim, name="cell_proj")(y)
+        y_cells = RMSNorm(name="cell_norm")(y_cells)
+        h = y_cells.reshape(B, 9 * cell_dim)
+
+        h = CommHead(
+            communication_dim=self.comm_dim,
+            comm_norm_type=self.comm_norm_type,
+            name="comm_head",
+        )(h)
+
+        x_pooled = jnp.mean(y, axis=1)
+
+        output = _ObjectiveHeads(
+            objective_mode=self.objective_mode,
+            comm_dim=self.comm_dim,
+            q_epsilon=self.q_epsilon,
+            q_diag_softplus=self.q_diag_softplus,
+            l1_weight=self.l1_weight,
+            l1_init=self.l1_init,
+            upper_init=self.upper_init,
+            beta_init=self.beta_init,
+            name="objective_heads",
+        )(h, x_pooled)
+
+        if self.rm_mode == "context":
+            d_e = self.edge_stalk_dim if self.edge_stalk_dim is not None else self.comm_dim
+            x_lora = RMSNorm(name="lora_pre_norm")(x_pooled)
+            output.update(
+                emit_lora_factors(
+                    x_lora,
+                    num_slots=self.num_directions,
+                    d_e=d_e,
+                    d_v=self.comm_dim,
+                    rank=self.lora_rank,
+                    init_style=self.lora_init_style,
+                    use_gate=self.lora_use_gate,
+                )
+            )
+        return output
+
+
+class MLPEncoder(nn.Module):
+    """Residual-MLP encoder (``arch="mlp"``). The camera-ready MNIST encoder.
+
+    Architecture: ``flatten -> Dense(hidden_dims[0]) -> MLPBlock x len(hidden_dims)``
+    (each a pre-norm + GELU + residual block) ``-> CommHead(comm_dim)``, then the
+    objective and (optional) LoRA heads. Differs from :class:`MLPEncoderV2` (which
+    is a single norm->Dense->GELU) by the input projection + residual blocks.
+    """
+
+    hidden_dims: tuple[int, ...] = (256,)
+    comm_dim: int = 32
+    edge_stalk_dim: int | None = None
+    comm_norm_type: str = "layernorm_zeros"
+    norm_type: str = "rmsnorm"
+    dropout_rate: float = 0.0
+
+    objective_mode: str = "simple"
+    q_epsilon: float = 1e-4
+    q_diag_softplus: bool = True
+    l1_weight: float = 0.0
+    l1_init: float = 0.01
+    upper_init: float = 1.0
+    beta_init: float = 1.0
+
+    rm_mode: str = "fixed"
+    lora_rank: int = 4
+    lora_use_gate: bool = False
+    lora_init_style: str = "legacy"
+    num_directions: int = 4
+
+    @nn.compact
+    def __call__(self, x: jnp.ndarray, training: bool = True) -> dict[str, Any]:
+        B = x.shape[0]
+        x = x.reshape((B, -1))
+        x = nn.Dense(self.hidden_dims[0], name="input_proj")(x)
+        for i, dim in enumerate(self.hidden_dims):
+            x = MLPBlock(out_dim=dim, norm_type=self.norm_type, name=f"block_{i}")(x)
+        if self.dropout_rate > 0:
+            x = nn.Dropout(rate=self.dropout_rate, deterministic=not training)(x)
+
+        h = CommHead(
+            communication_dim=self.comm_dim, comm_norm_type=self.comm_norm_type, name="comm_head"
+        )(x)
+        output = _ObjectiveHeads(
+            objective_mode=self.objective_mode,
+            comm_dim=self.comm_dim,
+            q_epsilon=self.q_epsilon,
+            q_diag_softplus=self.q_diag_softplus,
+            l1_weight=self.l1_weight,
+            l1_init=self.l1_init,
+            upper_init=self.upper_init,
+            beta_init=self.beta_init,
+            name="objective_heads",
+        )(h, x)
+        if self.rm_mode == "context":
+            d_e = self.edge_stalk_dim if self.edge_stalk_dim is not None else self.comm_dim
+            x_lora = nn.LayerNorm(name="lora_pre_ln")(x)
+            output.update(
+                emit_lora_factors(
+                    x_lora,
+                    num_slots=self.num_directions,
+                    d_e=d_e,
+                    d_v=self.comm_dim,
+                    rank=self.lora_rank,
+                    init_style=self.lora_init_style,
+                    use_gate=self.lora_use_gate,
+                )
+            )
+        return output
+
+
+def create_encoder(arch: str = "mlp_v2", **kwargs: Any) -> nn.Module:
+    """Build an encoder module by name.
+
+    ``arch`` in ``{"mlp_v2", "mlp", "sudoku"}``: ``mlp_v2`` (Maze, and the simple
+    single-layer MLP), ``mlp`` (the camera-ready MNIST residual-MLP encoder),
+    ``sudoku`` (the MLP-Mixer cell encoder). Unknown kwargs for the chosen arch
+    raise (no silent drops).
+    """
+    if arch == "mlp_v2":
+        return MLPEncoderV2(**kwargs)
+    if arch == "mlp":
+        return MLPEncoder(**kwargs)
+    if arch == "sudoku":
+        return SudokuEncoder(**kwargs)
+    raise ValueError(f"unknown encoder arch={arch!r} (mlp_v2|mlp|sudoku)")
diff --git a/src/sheaf_admm/models/layers.py b/src/sheaf_admm/models/layers.py
new file mode 100644
index 0000000000000000000000000000000000000000..00c015a291a6ba75661dad8b7ffd3d019dc8c41c
--- /dev/null
+++ b/src/sheaf_admm/models/layers.py
@@ -0,0 +1,174 @@
+"""Shared neural building blocks for the encoders, decoders, and MPNN baseline.
+
+Everything here is purely a network layer; the ADMM/sheaf machinery lives
+elsewhere.
+
+Conventions matched exactly to the paper runs:
+
+* ``RMSNorm`` — learnable per-channel scale, ``eps = 1e-6`` under the sqrt.
+* ``MLPBlock`` — pre-norm residual MLP ``x + Dense(GELU(Dense(Norm(x))))``, with a
+  learned residual projection when in/out widths differ.
+* ``MLPMixerBlock`` — TRM-style *post-norm* token/channel mixing with SwiGLU (or
+  GELU) sub-MLPs.
+* ``CommHead`` — final linear projection to the ``comm_dim`` consensus vector with
+  an optional normalization (the shipped configs use ``layernorm``).
+"""
+
+from __future__ import annotations
+
+import jax
+import jax.numpy as jnp
+from flax import linen as nn
+from flax.linen import initializers
+
+
+def rms_norm(x: jnp.ndarray, eps: float = 1e-6) -> jnp.ndarray:
+    """RMS normalization without learnable scale: ``x / sqrt(mean(x^2) + eps)``."""
+    variance = jnp.mean(x**2, axis=-1, keepdims=True)
+    return x * jax.lax.rsqrt(variance + eps)
+
+
+class RMSNorm(nn.Module):
+    """RMS layer normalization with a learnable per-channel scale (init 1)."""
+
+    eps: float = 1e-6
+
+    @nn.compact
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        scale = self.param("scale", nn.initializers.ones, (x.shape[-1],))
+        return rms_norm(x, self.eps) * scale
+
+
+class MLPBlock(nn.Module):
+    """Pre-norm residual MLP block: ``x + Dense(GELU(Dense(Norm(x))))``.
+
+    Uses a learned linear projection on the residual path when the input and
+    output widths differ. ``hidden_dim`` defaults to ``out_dim``.
+    """
+
+    out_dim: int
+    hidden_dim: int | None = None  # defaults to out_dim
+    norm_type: str = "rmsnorm"  # 'rmsnorm' | 'layernorm'
+    eps: float = 1e-6
+
+    @nn.compact
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        in_dim = x.shape[-1]
+        hidden_dim = self.hidden_dim if self.hidden_dim is not None else self.out_dim
+
+        if self.norm_type == "rmsnorm":
+            h = RMSNorm(eps=self.eps, name="norm")(x)
+        else:
+            h = nn.LayerNorm(epsilon=self.eps, name="norm")(x)
+
+        h = nn.Dense(hidden_dim, name="dense1")(h)
+        h = jax.nn.gelu(h)
+        h = nn.Dense(self.out_dim, name="dense2")(h)
+
+        if in_dim != self.out_dim:
+            x = nn.Dense(self.out_dim, name="residual_proj")(x)
+        return x + h
+
+
+class SwiGLU(nn.Module):
+    """SwiGLU MLP: ``Dense_down(silu(gate) * up)`` with a fused gate/up projection.
+
+    From Shazeer (2020), "GLU Variants Improve Transformer"; used by the Sudoku
+    mixer. The fused ``[gate, up]`` projection is a single matmul.
+    """
+
+    hidden_dim: int
+    out_dim: int
+
+    @nn.compact
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        gate_up = nn.Dense(2 * self.hidden_dim, name="gate_up")(x)
+        gate, up = jnp.split(gate_up, 2, axis=-1)
+        hidden = jax.nn.silu(gate) * up
+        return nn.Dense(self.out_dim, name="down")(hidden)
+
+
+class GeLUMLP(nn.Module):
+    """Two-layer GELU MLP ``Dense_down(gelu(Dense_up(x)))`` (no gating pathway)."""
+
+    hidden_dim: int
+    out_dim: int
+
+    @nn.compact
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        x = nn.Dense(self.hidden_dim, name="up")(x)
+        x = jax.nn.gelu(x)
+        return nn.Dense(self.out_dim, name="down")(x)
+
+
+class MLPMixerBlock(nn.Module):
+    """TRM-style post-norm MLP-Mixer block over ``[B, T, C]``.
+
+    Token mixing: ``x = RMSNorm(x + TokenMLP(x^T)^T)``;
+    channel mixing: ``x = RMSNorm(x + ChannelMLP(x))``. ``mlp_type`` selects the
+    SwiGLU or GELU sub-MLP (the paper Sudoku encoder uses ``swiglu``).
+    """
+
+    token_mlp_dim: int
+    channel_mlp_dim: int
+    mlp_type: str = "swiglu"  # "swiglu" | "gelu"
+    rms_eps: float = 1e-6
+
+    @nn.compact
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        T, C = x.shape[1], x.shape[2]
+
+        def make_mlp(hidden_dim: int, out_dim: int, name: str) -> nn.Module:
+            if self.mlp_type == "swiglu":
+                return SwiGLU(hidden_dim=hidden_dim, out_dim=out_dim, name=name)
+            if self.mlp_type == "gelu":
+                return GeLUMLP(hidden_dim=hidden_dim, out_dim=out_dim, name=name)
+            raise ValueError(f"unknown mlp_type={self.mlp_type!r} (swiglu|gelu)")
+
+        # Token mixing (post-norm): mix across the T axis.
+        y = jnp.swapaxes(x, 1, 2)  # [B, C, T]
+        y = make_mlp(self.token_mlp_dim, T, "token_mlp")(y)
+        y = jnp.swapaxes(y, 1, 2)  # [B, T, C]
+        x = RMSNorm(eps=self.rms_eps, name="token_norm")(x + y)
+
+        # Channel mixing (post-norm): mix across the C axis.
+        y = make_mlp(self.channel_mlp_dim, C, "channel_mlp")(x)
+        x = RMSNorm(eps=self.rms_eps, name="channel_norm")(x + y)
+        return x
+
+
+class CommHead(nn.Module):
+    """Project encoder features to the ``comm_dim`` consensus vector.
+
+    ``comm_norm_type`` post-processes the projection:
+
+    * ``identity`` — no normalization;
+    * ``tanh`` — squash to ``[-1, 1]``;
+    * ``layernorm`` — standard LayerNorm (the shipped configs' setting);
+    * ``layernorm_zeros`` — LayerNorm initialized near-off (scale ``1e-4``, bias
+      0), so the consensus vector starts close to zero.
+    """
+
+    communication_dim: int
+    comm_norm_type: str = "identity"
+
+    @nn.compact
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        comm = nn.Dense(features=self.communication_dim, name="comm_dense")(x)
+
+        if self.comm_norm_type == "tanh":
+            comm = nn.tanh(comm)
+        elif self.comm_norm_type == "layernorm":
+            comm = nn.LayerNorm(name="comm_norm")(comm)
+        elif self.comm_norm_type == "layernorm_zeros":
+            comm = nn.LayerNorm(
+                scale_init=initializers.constant(1e-4),
+                bias_init=initializers.zeros,
+                name="comm_norm",
+            )(comm)
+        elif self.comm_norm_type != "identity":
+            raise ValueError(
+                f"unknown comm_norm_type={self.comm_norm_type!r} "
+                "(identity|tanh|layernorm|layernorm_zeros)"
+            )
+        return comm
diff --git a/src/sheaf_admm/models/mpnn.py b/src/sheaf_admm/models/mpnn.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9e68ccc1dbc40928aa37c2853d24beed0df6bad
--- /dev/null
+++ b/src/sheaf_admm/models/mpnn.py
@@ -0,0 +1,236 @@
+"""Directional gated-GNN baseline: the MPNN ablation of the ADMM coordinator.
+
+This is the message-passing counterpart to the sheaf-ADMM loop. It reuses the
+**same** shared encoder (``objective_mode="simple"``, ``rm_mode="fixed"``) and
+decoder, but replaces the unrolled ADMM core with a recurrent gated graph net:
+agents exchange typed messages over the agent graph for ``num_rounds`` rounds,
+with weights shared across rounds (``nn.scan(variable_broadcast="params")``).
+
+Direction typing matches the geometry: ``shared`` (1 type), ``spatial``
+(connectivity 4/8 grid directions), or ``slot`` (9 Sudoku cell-slots).
+
+States carry the agent/batch layout ``[N, B, d]`` throughout (the segment ops in
+:class:`DirectionalGGNNCell` reduce over the N node axis; the B and d axes ride
+along). The parent supplies the encoder context ``[N, B, comm_dim]`` and the
+directed edge list / direction ids.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import jax
+import jax.numpy as jnp
+from flax import linen as nn
+
+from .layers import MLPBlock, RMSNorm
+
+
+class GraphClassificationHead(nn.Module):
+    """Graph-level readout: pooled node state -> class logits (MNIST MPNN).
+
+    ``linear_head=True`` is a bare ``Dense(output_channels)``; otherwise the
+    pooled vector runs through ``Dense(hidden_dims[0])`` then :class:`MLPBlock` s.
+    Consumes a mean/sum pool of the final node states ``[B', comm_dim]``.
+    """
+
+    hidden_dims: Sequence[int] = (128,)
+    output_channels: int = 10
+    norm_type: str = "rmsnorm"
+    linear_head: bool = False
+
+    @nn.compact
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        if self.linear_head:
+            return nn.Dense(features=self.output_channels, name="cls_output")(x)
+        h = nn.Dense(self.hidden_dims[0], name="input_proj")(x)
+        for i, dim in enumerate(self.hidden_dims):
+            h = MLPBlock(out_dim=dim, norm_type=self.norm_type, name=f"block_{i}")(h)
+        return nn.Dense(features=self.output_channels, name="cls_output")(h)
+
+
+class DirectionalGGNNCell(nn.Module):
+    """One gated message-passing round with direction-typed linear messages.
+
+    Per edge ``(src -> dst)`` with direction ``k``: message
+    ``W_k h_src + b_k`` (``W_dir`` ``[K, message_dim, hidden_dim]``), aggregated
+    over incoming edges (``add`` / ``mean`` / ``symnorm`` / ``max``), projected
+    ``message_dim -> hidden_dim`` if they differ, RMS/LayerNorm-ed, concatenated
+    with the (norm-ed) encoder ``context`` injected **every round**, then folded
+    into the hidden state by a GRU-like reset/update gate. Weights are per-cell;
+    the round-sharing happens in :class:`DirectionalGGNN`.
+    """
+
+    hidden_dim: int
+    message_dim: int
+    num_directions: int
+    aggregation: str = "add"  # "add" | "mean" | "symnorm" | "max"
+    norm_type: str = "rmsnorm"
+    eps: float = 1e-6
+
+    def _norm(self, x: jnp.ndarray, name: str) -> jnp.ndarray:
+        if self.norm_type == "layernorm":
+            return nn.LayerNorm(epsilon=self.eps, name=name)(x)
+        return RMSNorm(eps=self.eps, name=name)(x)
+
+    def _aggregate(
+        self,
+        messages: jnp.ndarray,  # [E, B, m]
+        src: jnp.ndarray,  # [E]
+        dst: jnp.ndarray,  # [E]
+        num_nodes: int,
+        self_messages: jnp.ndarray | None = None,
+    ) -> jnp.ndarray:
+        """Reduce per-edge messages onto destination nodes -> ``[N, B, m]``."""
+        if messages.shape[0] == 0:
+            agg = jnp.zeros((num_nodes, messages.shape[1], messages.shape[2]), messages.dtype)
+            if self.aggregation == "symnorm" and self_messages is not None:
+                return agg + self_messages
+            return agg
+
+        if self.aggregation == "add":
+            return jax.ops.segment_sum(messages, dst, num_segments=num_nodes)
+
+        if self.aggregation == "mean":
+            sums = jax.ops.segment_sum(messages, dst, num_segments=num_nodes)
+            ones = jnp.ones((messages.shape[0], 1, 1), messages.dtype)
+            counts = jax.ops.segment_sum(ones, dst, num_segments=num_nodes)
+            return sums / jnp.maximum(counts, 1.0)
+
+        if self.aggregation == "symnorm":
+            if self_messages is None:
+                raise ValueError("symnorm aggregation requires self_messages")
+            ones = jnp.ones((messages.shape[0],), messages.dtype)
+            src_deg = jax.ops.segment_sum(ones, src, num_segments=num_nodes) + 1.0
+            dst_deg = jax.ops.segment_sum(ones, dst, num_segments=num_nodes) + 1.0
+            edge_scale = jax.lax.rsqrt(src_deg[src] * dst_deg[dst])[:, None, None]
+            edge_sum = jax.ops.segment_sum(messages * edge_scale, dst, num_segments=num_nodes)
+            self_scale = (1.0 / dst_deg)[:, None, None]
+            return edge_sum + self_messages * self_scale
+
+        if self.aggregation == "max":
+            neg_inf = jnp.full(
+                (num_nodes, messages.shape[1], messages.shape[2]), -jnp.inf, messages.dtype
+            )
+            maxed = neg_inf.at[dst].max(messages)
+            return jnp.where(jnp.isfinite(maxed), maxed, 0.0)
+
+        raise ValueError(f"unknown aggregation={self.aggregation!r} (add|mean|symnorm|max)")
+
+    @nn.compact
+    def __call__(
+        self,
+        hidden: jnp.ndarray,  # [N, B, hidden_dim]
+        context: jnp.ndarray,  # [N, B, comm_dim] encoder context
+        edge_indices: jnp.ndarray,  # [E, 2] directed (src, dst)
+        direction_ids: jnp.ndarray,  # [E] direction type per edge
+    ) -> jnp.ndarray:
+        num_nodes = hidden.shape[0]
+        src, dst = edge_indices[:, 0], edge_indices[:, 1]
+
+        dir_kernel = self.param(
+            "dir_kernel",
+            nn.initializers.xavier_uniform(),
+            (self.num_directions, self.message_dim, self.hidden_dim),
+        )
+        dir_bias = self.param(
+            "dir_bias", nn.initializers.zeros, (self.num_directions, self.message_dim)
+        )
+        edge_kernel = dir_kernel[direction_ids]  # [E, m, d]
+        edge_bias = dir_bias[direction_ids]  # [E, m]
+        messages = jnp.einsum("emd,ebd->ebm", edge_kernel, hidden[src])
+        messages = messages + edge_bias[:, None, :]
+
+        if self.aggregation == "symnorm":
+            if self.message_dim == self.hidden_dim:
+                self_messages = hidden
+            else:
+                self_messages = nn.Dense(
+                    self.message_dim, use_bias=False, name="self_message_to_edge"
+                )(hidden)
+        else:
+            self_messages = None
+
+        aggregated = self._aggregate(messages, src, dst, num_nodes, self_messages)
+        if self.message_dim != self.hidden_dim:
+            aggregated = nn.Dense(self.hidden_dim, use_bias=False, name="message_to_hidden")(
+                aggregated
+            )
+
+        aggregated = self._norm(aggregated, name="aggregated_norm")
+        context = self._norm(context, name="context_norm")
+        update_inputs = jnp.concatenate([aggregated, context], axis=-1)
+        update_inputs = nn.Dense(self.hidden_dim, name="update_input")(update_inputs)
+
+        gate_inputs = self._norm(
+            jnp.concatenate([hidden, update_inputs], axis=-1), name="gate_norm"
+        )
+        reset_gate = nn.sigmoid(nn.Dense(self.hidden_dim, name="reset_gate")(gate_inputs))
+        update_gate = nn.sigmoid(nn.Dense(self.hidden_dim, name="update_gate")(gate_inputs))
+
+        candidate_inputs = self._norm(
+            jnp.concatenate([reset_gate * hidden, update_inputs], axis=-1),
+            name="candidate_norm",
+        )
+        candidate = nn.tanh(nn.Dense(self.hidden_dim, name="candidate")(candidate_inputs))
+        return (1.0 - update_gate) * candidate + update_gate * hidden
+
+
+class DirectionalGGNN(nn.Module):
+    """Round-recurrent directional GGNN processor (weights shared across rounds).
+
+    Runs :class:`DirectionalGGNNCell` for ``num_rounds`` rounds via
+    ``nn.scan(variable_broadcast="params")`` so a single set of cell weights is
+    reused every round (the recurrent ablation of the ADMM loop). Returns the
+    final node hidden state ``[N, B, hidden_dim]``; with ``return_history=True``
+    also returns the stacked per-round states ``[num_rounds, N, B, hidden_dim]``.
+    """
+
+    hidden_dim: int
+    message_dim: int
+    num_directions: int
+    aggregation: str = "add"
+    norm_type: str = "rmsnorm"
+    eps: float = 1e-6
+
+    @nn.compact
+    def __call__(
+        self,
+        hidden0: jnp.ndarray,  # [N, B, hidden_dim]
+        context: jnp.ndarray,  # [N, B, comm_dim]
+        edge_indices: jnp.ndarray,  # [E, 2] directed
+        direction_ids: jnp.ndarray,  # [E]
+        num_rounds: int,
+        return_history: bool = False,
+    ) -> jnp.ndarray | tuple[jnp.ndarray, jnp.ndarray]:
+        if num_rounds < 1:
+            raise ValueError("num_rounds must be >= 1")
+
+        cell = DirectionalGGNNCell(
+            hidden_dim=self.hidden_dim,
+            message_dim=self.message_dim,
+            num_directions=self.num_directions,
+            aggregation=self.aggregation,
+            norm_type=self.norm_type,
+            eps=self.eps,
+            name="cell",
+        )
+
+        def body(cell: DirectionalGGNNCell, hidden: jnp.ndarray, _step: Any):
+            next_hidden = cell(hidden, context, edge_indices, direction_ids)
+            return next_hidden, (next_hidden if return_history else None)
+
+        scan = nn.scan(
+            body,
+            variable_broadcast="params",
+            split_rngs={"params": False},
+            in_axes=0,
+            out_axes=0,
+            length=num_rounds,
+        )
+        steps = jnp.arange(num_rounds, dtype=jnp.int32)
+        hidden_final, history = scan(cell, hidden0, steps)
+        if return_history:
+            return hidden_final, history
+        return hidden_final
diff --git a/src/sheaf_admm/models/mpnn_model.py b/src/sheaf_admm/models/mpnn_model.py
new file mode 100644
index 0000000000000000000000000000000000000000..6618eb2c23864351aece21fe9d10787ec1580237
--- /dev/null
+++ b/src/sheaf_admm/models/mpnn_model.py
@@ -0,0 +1,148 @@
+"""The recurrent-MPNN baseline model.
+
+The baseline uses the same task decompositions and decoder interfaces as
+:class:`~sheaf_admm.models.sheaf_model.SheafADMMModel`, but replaces the
+unrolled ADMM loop with a directional gated-GNN
+(:class:`~sheaf_admm.models.mpnn.DirectionalGGNN`).
+
+The encoder is used in ``objective_mode="simple"`` / ``rm_mode="fixed"`` (the GGNN
+consumes only the consensus seed ``h`` as its per-round context, not the convex
+objective params). Readout is per-agent decode + overlap-average (Maze/Sudoku) or
+graph-level mean-pool (MNIST), matching the Sheaf model's readout per task.
+"""
+
+from __future__ import annotations
+
+import jax.numpy as jnp
+from flax import linen as nn
+
+from sheaf_admm.geometry import compute_direction_index
+
+from .config import ModelConfig
+from .decoder import create_decoder
+from .encoder import create_encoder
+from .mpnn import DirectionalGGNN, GraphClassificationHead
+
+
+class MPNNModel(nn.Module):
+    """Directional-GGNN baseline (see module docstring)."""
+
+    config: ModelConfig
+
+    def _directed_edges(self, edge_indices, node_positions, map_u, map_v):
+        """Double the undirected edges and assign a direction/type id per directed edge."""
+        c = self.config
+        u, v = edge_indices[:, 0], edge_indices[:, 1]
+        directed = jnp.concatenate([edge_indices, jnp.stack([v, u], axis=1)], axis=0)
+
+        if c.mpnn_edge_type_mode == "shared":
+            dir_ids = jnp.zeros((directed.shape[0],), dtype=jnp.int32)
+            num_types = 1
+        elif c.mpnn_edge_type_mode == "spatial":
+            dy = node_positions[v, 0] - node_positions[u, 0]
+            dx = node_positions[v, 1] - node_positions[u, 1]
+            fwd = compute_direction_index(dy, dx, c.num_directions)
+            bwd = compute_direction_index(-dy, -dx, c.num_directions)
+            dir_ids = jnp.concatenate([fwd, bwd]).astype(jnp.int32)
+            num_types = c.num_directions
+        elif c.mpnn_edge_type_mode == "slot":
+            dir_ids = jnp.concatenate([map_u, map_v]).astype(jnp.int32)
+            num_types = 9
+        else:
+            raise ValueError(f"unknown mpnn_edge_type_mode={c.mpnn_edge_type_mode!r}")
+        return directed, dir_ids, num_types
+
+    @nn.compact
+    def __call__(
+        self,
+        patches: jnp.ndarray,  # [N,B,...]
+        edge_indices: jnp.ndarray,  # [E, 2] undirected
+        *,
+        num_rounds: int,
+        node_positions: jnp.ndarray | None = None,
+        map_u: jnp.ndarray | None = None,
+        map_v: jnp.ndarray | None = None,
+        cell_ids: jnp.ndarray | None = None,
+        training: bool = True,
+    ):
+        c = self.config
+        N, B = patches.shape[:2]
+
+        # Shared encoder (simple/fixed) -> per-agent context h.
+        enc_kwargs = dict(
+            comm_dim=c.d_v,
+            edge_stalk_dim=c.d_e,
+            comm_norm_type=c.comm_norm_type,
+            objective_mode="simple",
+            rm_mode="fixed",
+            beta_init=c.beta_init,
+        )
+        if c.encoder_arch == "mlp_v2":
+            enc_kwargs.update(hidden_dim=c.enc_hidden_dim, dropout_rate=c.dropout_rate)
+            encoder = create_encoder("mlp_v2", **enc_kwargs)
+            enc = encoder(patches.reshape((N * B, *patches.shape[2:])), training=training)
+        elif c.encoder_arch == "mlp":
+            enc_kwargs.update(hidden_dims=(c.enc_hidden_dim,), dropout_rate=c.dropout_rate)
+            encoder = create_encoder("mlp", **enc_kwargs)
+            enc = encoder(patches.reshape((N * B, *patches.shape[2:])), training=training)
+        elif c.encoder_arch == "sudoku":
+            enc_kwargs.update(d_model=c.enc_d_model, num_blocks=c.enc_num_blocks)
+            encoder = create_encoder("sudoku", **enc_kwargs)
+            cids = None
+            if cell_ids is not None:
+                cids = jnp.broadcast_to(cell_ids[:, None, :], (N, B, cell_ids.shape[-1]))
+                cids = cids.reshape((N * B, cell_ids.shape[-1]))
+            enc = encoder(patches.reshape((N * B, *patches.shape[2:])), cids)
+        else:
+            raise ValueError(f"unknown encoder_arch={c.encoder_arch!r}")
+        context = enc["h"].reshape((N, B, c.d_v))
+
+        hidden0 = nn.Dense(c.d_v, name="init_hidden")(context)
+        directed, dir_ids, num_types = self._directed_edges(
+            edge_indices, node_positions, map_u, map_v
+        )
+        ggnn = DirectionalGGNN(
+            hidden_dim=c.d_v,
+            message_dim=c.mpnn_message_dim or c.d_e,
+            num_directions=num_types,
+            aggregation=c.mpnn_aggregation,
+            name="ggnn",
+        )
+        hidden_final = ggnn(hidden0, context, directed, dir_ids, num_rounds)
+
+        patches_flat = patches.reshape((N * B, *patches.shape[2:]))
+        if c.mpnn_graph_readout == "graph":
+            pooled = jnp.mean(hidden_final, axis=0)  # [B, d_v]
+            head = GraphClassificationHead(
+                hidden_dims=c.dec_hidden_dims,
+                output_channels=c.num_classes,
+                norm_type=c.dec_norm_type,
+                linear_head=c.dec_linear_head,
+            )
+            return head(pooled), hidden_final
+
+        # per-agent decode (shared decoder), then [N,B,*out]
+        dec_kwargs: dict = {}
+        if c.decoder_arch == "mlp_concat_v2":
+            dec_kwargs = dict(
+                hidden_dim=c.dec_hidden_dim,
+                output_shape=(*patches.shape[2:-1], c.num_classes),
+                dropout_rate=c.dropout_rate,
+            )
+        elif c.decoder_arch == "sudoku":
+            dec_kwargs = dict(
+                hidden_dims=c.dec_hidden_dims,
+                output_channels=c.num_classes,
+                norm_type=c.dec_norm_type,
+            )
+        elif c.decoder_arch == "classification":
+            dec_kwargs = dict(
+                hidden_dims=c.dec_hidden_dims,
+                output_channels=c.num_classes,
+                norm_type=c.dec_norm_type,
+                linear_head=c.dec_linear_head,
+                readout_mode=c.dec_readout_mode,
+            )
+        decoder = create_decoder(c.decoder_arch, **dec_kwargs)
+        logits = decoder(hidden_final.reshape((N * B, c.d_v)), patches_flat, training=training)
+        return logits.reshape((N, B, *logits.shape[1:])), hidden_final
diff --git a/src/sheaf_admm/models/sheaf_model.py b/src/sheaf_admm/models/sheaf_model.py
new file mode 100644
index 0000000000000000000000000000000000000000..09263401f3c079890e068734c718cfa041f27be0
--- /dev/null
+++ b/src/sheaf_admm/models/sheaf_model.py
@@ -0,0 +1,345 @@
+"""The full Sheaf-ADMM model: encode -> coordinate (ADMM) -> decode.
+
+This ties the pieces together as one Flax module:
+
+1. a **shared encoder** maps each agent's local view to its convex-subproblem
+   parameters and a consensus seed ``h``;
+2. **restriction maps** (shared by direction / globally / by Sudoku cell-slot,
+   optionally LoRA-modulated by the encoder) define the sheaf geometry;
+3. the **unrolled ADMM loop** (:func:`sheaf_admm.admm.run_admm`) coordinates the
+   agents with learned penalty ``rho`` (and step ``eta`` for the GD z-solver);
+4. a **shared decoder** maps the final per-agent states to per-agent logits.
+
+The model returns per-agent logits over the final ``loss_window`` ADMM iterates;
+the trainer handles the loss-window averaging and (for eval) the overlap
+reassembly into a global prediction. The agent graph is passed in per call, so
+the same trained weights apply to larger inputs (size generalization).
+"""
+
+from __future__ import annotations
+
+import jax
+import jax.numpy as jnp
+from flax import linen as nn
+
+from sheaf_admm.admm import inverse_softplus, run_admm, run_admm_history
+from sheaf_admm.geometry import (
+    DirectionalRestrictionMaps,
+    FixedGeometry,
+    SharedRestrictionMap,
+    SudokuRestrictionMaps,
+    build_directional_restriction_maps,
+    build_shared_restriction_maps,
+    build_sudoku_restriction_maps,
+    literal_sudoku_identity_maps,
+    create_lora_geometry,
+    create_sudoku_lora_geometry,
+)
+from sheaf_admm.solvers.x_solvers import make_x_solver
+from sheaf_admm.solvers.z_solvers import GDParams, UnrolledCGParams, make_z_solver
+
+from .config import ModelConfig
+from .decoder import create_decoder
+from .encoder import create_encoder
+
+_ARRAY_KEYS = ("h", "q_diag", "q", "l1_weight", "upper", "A", "B", "gate")
+
+
+def _logit(p: float) -> float:
+    return float(jnp.log(p / (1.0 - p)))
+
+
+class SheafADMMModel(nn.Module):
+    """End-to-end Sheaf-ADMM model (see module docstring)."""
+
+    config: ModelConfig
+
+    # ---- learned ADMM scalars (offset-softplus so the init is exact) ----
+    def _learned_scalar(self, name: str, init: float, learnable: bool) -> jnp.ndarray:
+        delta = self.param(name, nn.initializers.zeros, ())
+        if not learnable:
+            delta = jax.lax.stop_gradient(delta)
+        return jax.nn.softplus(delta + inverse_softplus(init))
+
+    def _learned_eta(self) -> jnp.ndarray:
+        c = self.config
+        if c.eta_min is not None and c.eta_max is not None:
+            # Bounded log-space leash: keeps the GD step size inside [eta_min, eta_max]
+            # so the inner diffusion cannot diverge.
+            lo, hi = jnp.log(c.eta_min), jnp.log(c.eta_max)
+            t0 = jnp.clip((jnp.log(c.eta_init) - lo) / (hi - lo), 1e-6, 1 - 1e-6)
+            raw = self.param("eta_raw", nn.initializers.zeros, ()) + _logit(float(t0))
+            if not c.eta_learnable:
+                raw = jax.lax.stop_gradient(raw)
+            return jnp.exp(lo + jax.nn.sigmoid(raw) * (hi - lo))
+        return self._learned_scalar("eta_raw", c.eta_init, c.eta_learnable)
+
+    # ---- encoder application (shared across agents) ----
+    def _encode(self, patches, cell_ids, training):
+        c = self.config
+        N, B = patches.shape[:2]
+        enc_kwargs = dict(
+            comm_dim=c.d_v,
+            edge_stalk_dim=c.d_e,
+            comm_norm_type=c.comm_norm_type,
+            objective_mode=c.objective_mode,
+            q_epsilon=c.q_epsilon,
+            l1_weight=c.l1_weight,
+            l1_init=c.l1_init,
+            upper_init=c.upper_init,
+            beta_init=c.beta_init,
+            rm_mode=c.rm_mode,
+            lora_rank=c.lora_rank,
+            lora_use_gate=c.lora_use_gate,
+            lora_init_style=c.lora_init_style,
+            num_directions=c.num_directions,
+        )
+        if c.encoder_arch == "mlp_v2":
+            enc_kwargs.update(hidden_dim=c.enc_hidden_dim, dropout_rate=c.dropout_rate)
+            encoder = create_encoder("mlp_v2", **enc_kwargs)
+            flat = encoder(patches.reshape((N * B, *patches.shape[2:])), training=training)
+        elif c.encoder_arch == "mlp":
+            enc_kwargs.update(hidden_dims=(c.enc_hidden_dim,), dropout_rate=c.dropout_rate)
+            encoder = create_encoder("mlp", **enc_kwargs)
+            flat = encoder(patches.reshape((N * B, *patches.shape[2:])), training=training)
+        elif c.encoder_arch == "sudoku":
+            enc_kwargs.update(d_model=c.enc_d_model, num_blocks=c.enc_num_blocks)
+            encoder = create_encoder("sudoku", **enc_kwargs)
+            cids = None
+            if cell_ids is not None:
+                cids = jnp.broadcast_to(cell_ids[:, None, :], (N, B, cell_ids.shape[-1]))
+                cids = cids.reshape((N * B, cell_ids.shape[-1]))
+            flat = encoder(patches.reshape((N * B, *patches.shape[2:])), cids)
+        else:
+            raise ValueError(f"unknown encoder_arch={c.encoder_arch!r}")
+
+        out = dict(flat)
+        for k in _ARRAY_KEYS:
+            if k in out and jnp.ndim(out[k]) >= 1 and out[k].shape[0] == N * B:
+                out[k] = out[k].reshape((N, B, *out[k].shape[1:]))
+        return out
+
+    # ---- geometry assembly ----
+    def _build_geometry(self, enc_out, edge_indices, node_positions, map_u, map_v, edge_mask):
+        c = self.config
+        E = edge_indices.shape[0]
+        if c.rm_sharing == "directional":
+            R_dict = DirectionalRestrictionMaps(
+                stalk_dim=c.d_v,
+                edge_stalk_dim=c.d_e,
+                init_method=c.rm_init,
+                num_directions=c.num_directions,
+                name="rm",
+            )()
+            base = build_directional_restriction_maps(
+                R_dict, edge_indices, node_positions, c.num_directions
+            )
+        elif c.rm_sharing == "global":
+            R = SharedRestrictionMap(
+                stalk_dim=c.d_v, edge_stalk_dim=c.d_e, init_method=c.rm_init, name="rm"
+            )()
+            base = build_shared_restriction_maps(R, E)
+        elif c.rm_sharing == "sudoku":
+            if c.rm_constant:
+                if c.rm_init != "identity" or c.rm_mode != "fixed":
+                    raise ValueError(
+                        "rm_constant requires rm_init='identity' and rm_mode='fixed'"
+                    )
+                base = literal_sudoku_identity_maps(c.d_e, c.d_v, map_u, map_v)
+            else:
+                R_stack = SudokuRestrictionMaps(
+                    stalk_dim=c.d_v, edge_stalk_dim=c.d_e, init_method=c.rm_init, name="rm"
+                )()
+                base = build_sudoku_restriction_maps(R_stack, map_u, map_v)
+        else:
+            raise ValueError(f"unknown rm_sharing={c.rm_sharing!r} (directional|global|sudoku)")
+
+        if c.rm_mode == "fixed":
+            return FixedGeometry(
+                edge_indices=edge_indices, restriction_maps=base, edge_mask=edge_mask
+            )
+        if c.rm_mode == "context":
+            A, Bf, gate = enc_out["A"], enc_out["B"], enc_out.get("gate")
+            if c.rm_sharing == "sudoku":
+                return create_sudoku_lora_geometry(
+                    edge_indices,
+                    map_u,
+                    map_v,
+                    base,
+                    A,
+                    Bf,
+                    c.lora_alpha,
+                    gate=gate,
+                    edge_mask=edge_mask,
+                )
+            return create_lora_geometry(
+                edge_indices,
+                node_positions,
+                base,
+                A,
+                Bf,
+                c.lora_alpha,
+                c.num_directions,
+                gate=gate,
+                edge_mask=edge_mask,
+            )
+        raise ValueError(f"unknown rm_mode={c.rm_mode!r} (fixed|context)")
+
+    # ---- z-solver params (rho/eta baked in per call) ----
+    def _z_params(self, rho):
+        c = self.config
+        if c.z_solver == "unrolled_cg":
+            return UnrolledCGParams(
+                mode=c.z_mode,
+                gamma=c.gamma,
+                num_iters=c.cg_iters,
+                tikhonov_eps=c.tikhonov_eps,
+                prox_init=c.prox_init,
+            )
+        if c.z_solver == "gd":
+            return GDParams(
+                mode=c.z_mode,
+                gamma=c.gamma,
+                num_steps=c.gd_steps,
+                momentum=c.gd_momentum,
+                eta=self._learned_eta(),
+            )
+        raise ValueError(f"unknown z_solver={c.z_solver!r} (unrolled_cg|gd)")
+
+    def _decode_window(self, x_window, patches, training):
+        """Decode each of the W windowed agent states -> per-agent logits [W, N, B, *out]."""
+        c = self.config
+        W, N, B = x_window.shape[:3]
+        dec_kwargs: dict = {}
+        if c.decoder_arch == "mlp_concat_v2":
+            dec_kwargs = dict(
+                hidden_dim=c.dec_hidden_dim,
+                output_shape=(*patches.shape[2:-1], c.num_classes),
+                dropout_rate=c.dropout_rate,
+            )
+        elif c.decoder_arch == "sudoku":
+            dec_kwargs = dict(
+                hidden_dims=c.dec_hidden_dims,
+                output_channels=c.num_classes,
+                norm_type=c.dec_norm_type,
+            )
+        elif c.decoder_arch == "classification":
+            dec_kwargs = dict(
+                hidden_dims=c.dec_hidden_dims,
+                output_channels=c.num_classes,
+                norm_type=c.dec_norm_type,
+                linear_head=c.dec_linear_head,
+                readout_mode=c.dec_readout_mode,
+            )
+        else:
+            raise ValueError(f"unknown decoder_arch={c.decoder_arch!r}")
+        decoder = create_decoder(c.decoder_arch, **dec_kwargs)
+
+        patches_flat = patches.reshape((N * B, *patches.shape[2:]))
+        outs = []
+        for w in range(W):
+            xw = x_window[w].reshape((N * B, c.d_v))
+            logits = decoder(xw, patches_flat, training=training)
+            outs.append(logits.reshape((N, B, *logits.shape[1:])))
+        return jnp.stack(outs, axis=0)
+
+    def _setup_admm(
+        self, patches, edge_indices, node_positions, map_u, map_v, cell_ids, edge_mask, training
+    ):
+        """Build everything the ADMM loop needs (encoder out, geometry, solvers, rho, z_init).
+
+        Shared by :meth:`__call__` and :meth:`coordinate_history` so the two
+        entry points see identical parameters and setup.
+        """
+        c = self.config
+        enc_out = self._encode(patches, cell_ids, training)
+        geometry = self._build_geometry(
+            enc_out, edge_indices, node_positions, map_u, map_v, edge_mask
+        )
+        rho = self._learned_scalar("rho_raw", c.rho_init, c.rho_learnable)
+        x_solver, x_params = make_x_solver(c.x_solver)
+        z_solver, _ = make_z_solver(c.z_solver)
+        z_params = self._z_params(rho)
+        z_init = enc_out["h"] if c.z_init == "h" else jnp.zeros_like(enc_out["h"])
+        return enc_out, geometry, rho, x_solver, x_params, z_solver, z_params, z_init
+
+    @nn.compact
+    def __call__(
+        self,
+        patches: jnp.ndarray,  # grid: [N,B,ph,pw,C]; sudoku: [N,B,9,10]
+        edge_indices: jnp.ndarray,  # [E, 2]
+        *,
+        num_iters: int,
+        loss_window: int = 1,
+        grad_window: int | None = None,
+        node_positions: jnp.ndarray | None = None,  # grid [N,2]
+        map_u: jnp.ndarray | None = None,  # sudoku [E]
+        map_v: jnp.ndarray | None = None,  # sudoku [E]
+        cell_ids: jnp.ndarray | None = None,  # sudoku [N,9]
+        edge_mask: jnp.ndarray | None = None,  # [E] or [E,B]
+        training: bool = True,
+    ):
+        c = self.config
+        enc_out, geometry, rho, x_solver, x_params, z_solver, z_params, z_init = self._setup_admm(
+            patches, edge_indices, node_positions, map_u, map_v, cell_ids, edge_mask, training
+        )
+        final_state, x_window = run_admm(
+            enc_out,
+            geometry,
+            x_solver,
+            x_params,
+            z_solver,
+            z_params,
+            rho,
+            z_init,
+            num_iters,
+            relaxation_alpha=c.relaxation_alpha,
+            loss_window=loss_window,
+            grad_window=grad_window,
+        )
+        logits_window = self._decode_window(x_window, patches, training)
+        return logits_window, final_state, geometry
+
+    @nn.compact
+    def coordinate_history(
+        self,
+        patches: jnp.ndarray,
+        edge_indices: jnp.ndarray,
+        *,
+        num_iters: int,
+        node_positions: jnp.ndarray | None = None,
+        map_u: jnp.ndarray | None = None,
+        map_v: jnp.ndarray | None = None,
+        cell_ids: jnp.ndarray | None = None,
+        edge_mask: jnp.ndarray | None = None,
+        training: bool = False,
+    ):
+        """Forward-only path returning the full per-iteration ADMM trajectory.
+
+        Mirrors :meth:`__call__` but records every iterate and its residuals (see
+        :class:`sheaf_admm.admm.ADMMHistory`) and decodes each local proposal
+        ``x^k`` to per-agent logits ``[K, N, B, *out]``. Invoke via
+        ``model.apply(params, ..., method=SheafADMMModel.coordinate_history)``;
+        because the submodule names match :meth:`__call__`, it reuses the trained
+        parameters without re-initialization.
+        """
+        c = self.config
+        enc_out, geometry, rho, x_solver, x_params, z_solver, z_params, z_init = self._setup_admm(
+            patches, edge_indices, node_positions, map_u, map_v, cell_ids, edge_mask, training
+        )
+        final_state, history = run_admm_history(
+            enc_out,
+            geometry,
+            x_solver,
+            x_params,
+            z_solver,
+            z_params,
+            rho,
+            z_init,
+            num_iters,
+            relaxation_alpha=c.relaxation_alpha,
+        )
+        # Decode each local proposal x^k -> per-agent logits [K, N, B, *out]
+        # (the prediction is read off the x-iterate, matching the training loss).
+        logits_per_iter = self._decode_window(history.x, patches, training)
+        return history, logits_per_iter, final_state, geometry, rho
diff --git a/src/sheaf_admm/precision.py b/src/sheaf_admm/precision.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e44594e27595e4b1c7a8bc7f5c9d7c5a7b3df47
--- /dev/null
+++ b/src/sheaf_admm/precision.py
@@ -0,0 +1,30 @@
+"""Global float32 matmul precision.
+
+Sheaf-ADMM runs many chained matmuls inside the unrolled z-update (conjugate
+gradient / gradient descent on the sheaf Laplacian ``F^T F``). On GPU/TPU, JAX
+defaults to lower-precision matmuls (TF32-style, ~10-bit mantissa), which
+corrupts the CG residual orthogonality over the fixed ``T`` steps and injects
+noise into the unrolled gradients. The paper sets matmul precision to
+``highest`` (true float32) for every run; reproducing the reported numbers
+depends on it.
+
+We enforce this once, at import time, unless the user has already pinned the
+precision via the ``JAX_DEFAULT_MATMUL_PRECISION`` environment variable.
+"""
+
+from __future__ import annotations
+
+import os
+
+import jax
+
+
+def set_high_precision() -> None:
+    """Set JAX default matmul precision to ``highest`` unless already configured.
+
+    Respects a pre-existing ``JAX_DEFAULT_MATMUL_PRECISION`` env var so callers
+    can opt out (e.g. ``JAX_DEFAULT_MATMUL_PRECISION=default``).
+    """
+    if os.environ.get("JAX_DEFAULT_MATMUL_PRECISION"):
+        return
+    jax.config.update("jax_default_matmul_precision", "highest")
diff --git a/src/sheaf_admm/solvers/__init__.py b/src/sheaf_admm/solvers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cde010ee75bd0c5d9ee65e0d0ffdcb044e292037
--- /dev/null
+++ b/src/sheaf_admm/solvers/__init__.py
@@ -0,0 +1,20 @@
+"""ADMM inner solvers: x-update (local prox) and z-update (sheaf consensus)."""
+
+from __future__ import annotations
+
+from .base import XSolver, XSolverParams, ZSolver, ZSolverParams, rho_as_vec, soft_threshold
+from .x_solvers import X_SOLVERS, make_x_solver
+from .z_solvers import Z_SOLVERS, make_z_solver
+
+__all__ = [
+    "XSolver",
+    "XSolverParams",
+    "ZSolver",
+    "ZSolverParams",
+    "rho_as_vec",
+    "soft_threshold",
+    "X_SOLVERS",
+    "make_x_solver",
+    "Z_SOLVERS",
+    "make_z_solver",
+]
diff --git a/src/sheaf_admm/solvers/base.py b/src/sheaf_admm/solvers/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..766ab8270ed3a43d025253006b6951cf00286392
--- /dev/null
+++ b/src/sheaf_admm/solvers/base.py
@@ -0,0 +1,84 @@
+"""Solver protocols and shared helpers for the ADMM inner updates.
+
+The ADMM loop is polymorphic over two solver families:
+
+* **x-solvers** implement the local proximal step
+  ``x_i = argmin_{x} f_i(x) + (rho/2)||x - (z_i - y_i)||^2``,
+  where the convex ``f_i`` is parameterized by the encoder. ``y`` is the
+  *scaled* dual (``u = lambda / rho``), so the prox center is ``v = z - y``.
+* **z-solvers** implement the consensus step over the sheaf (see
+  :mod:`sheaf_admm.solvers.z_solvers`).
+
+Both take a small frozen ``*Params`` dataclass and are looked up by name in a
+registry, so a config string selects the update rule.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Protocol
+
+import jax.numpy as jnp
+from flax import struct
+
+from sheaf_admm.geometry.base import SheafGeometry
+
+
+@struct.dataclass
+class XSolverParams:
+    """Base config for an x-solver. Subclasses add solver-specific fields."""
+
+
+@struct.dataclass
+class ZSolverParams:
+    """Base config for a z-solver.
+
+    ``mode`` selects the consensus objective:
+
+    * ``"project"`` — hard-consensus update toward ``ker(F)`` (``F z = 0``).
+    * ``"prox"`` — soft consensus, minimize ``gamma * E_sheaf(z) + rho/2 ||z - z_target||^2``.
+    """
+
+    mode: str = "prox"  # "project" | "prox"
+    gamma: float = 1.0  # weight on sheaf energy (prox mode); the paper's gamma
+
+
+class XSolver(Protocol):
+    """x-update: local proximal solve, ``v = z - y`` is the prox center."""
+
+    @staticmethod
+    def solve(
+        z: jnp.ndarray,  # [N, B, d_v]
+        y: jnp.ndarray,  # [N, B, d_v] scaled dual
+        rho: jnp.ndarray,  # scalar or [N, B]
+        encoder_output: dict[str, Any],
+        params: XSolverParams,
+    ) -> jnp.ndarray:  # x_new [N, B, d_v]
+        ...
+
+
+class ZSolver(Protocol):
+    """z-update: sheaf consensus. ``z_target = x + y``."""
+
+    @staticmethod
+    def solve(
+        z_target: jnp.ndarray,  # [N, B, d_v]
+        z_prev: jnp.ndarray,  # [N, B, d_v] previous z (warm-start)
+        geometry: SheafGeometry,
+        params: ZSolverParams,
+        rho: jnp.ndarray,  # scalar or [N, B]; used only in prox mode
+    ) -> jnp.ndarray:  # z_new [N, B, d_v]
+        ...
+
+
+def rho_as_vec(rho: jnp.ndarray, like: jnp.ndarray) -> jnp.ndarray:
+    """Broadcast ``rho`` against node states ``like`` of shape ``[N, B, d_v]``.
+
+    A scalar stays scalar; a per-agent ``[N, B]`` rho becomes ``[N, B, 1]``.
+    """
+    rho = jnp.asarray(rho, dtype=like.dtype)
+    return rho[..., None] if rho.ndim == 2 else rho
+
+
+def soft_threshold(x: jnp.ndarray, threshold: jnp.ndarray) -> jnp.ndarray:
+    """Proximal operator of the L1 norm: ``sign(x) * max(|x| - threshold, 0)``."""
+    return jnp.sign(x) * jnp.maximum(jnp.abs(x) - threshold, 0.0)
diff --git a/src/sheaf_admm/solvers/x_solvers/__init__.py b/src/sheaf_admm/solvers/x_solvers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..da3974f4910cd103ac0d94ebb633200605b98ae6
--- /dev/null
+++ b/src/sheaf_admm/solvers/x_solvers/__init__.py
@@ -0,0 +1,41 @@
+"""x-update solvers (per-agent local proximal step) and their registry.
+
+* ``diagonal_prox`` — unified diagonal closed form (quadratic / lasso /
+  non-negative / L1+box, selected by what the encoder emits); the solver the
+  shipped sheaf configs use.
+* ``simple`` — tether ``(beta/2)||x - h||^2``.
+* ``dense_quadratic`` — linear solve for non-diagonal ``Q``; useful for tests
+  and custom encoders that emit dense quadratic objectives.
+"""
+
+from __future__ import annotations
+
+from .dense_quadratic import DenseQuadraticParams, DenseQuadraticXSolver
+from .diagonal_prox import DiagonalProxParams, DiagonalProxXSolver
+from .simple import SimpleParams, SimpleXSolver
+
+X_SOLVERS = {
+    "simple": (SimpleXSolver, SimpleParams),
+    "diagonal_prox": (DiagonalProxXSolver, DiagonalProxParams),
+    "dense_quadratic": (DenseQuadraticXSolver, DenseQuadraticParams),
+}
+
+
+def make_x_solver(name: str):
+    """Return ``(solver_cls, default_params)`` for an x-solver name."""
+    if name not in X_SOLVERS:
+        raise KeyError(f"unknown x-solver {name!r}; available: {sorted(X_SOLVERS)}")
+    cls, params_cls = X_SOLVERS[name]
+    return cls, params_cls()
+
+
+__all__ = [
+    "X_SOLVERS",
+    "make_x_solver",
+    "SimpleXSolver",
+    "SimpleParams",
+    "DiagonalProxXSolver",
+    "DiagonalProxParams",
+    "DenseQuadraticXSolver",
+    "DenseQuadraticParams",
+]
diff --git a/src/sheaf_admm/solvers/x_solvers/dense_quadratic.py b/src/sheaf_admm/solvers/x_solvers/dense_quadratic.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a567f8077a4ad2d53d913eceeef8a94a20d7cfc
--- /dev/null
+++ b/src/sheaf_admm/solvers/x_solvers/dense_quadratic.py
@@ -0,0 +1,39 @@
+"""Dense quadratic x-solver: ``f_i(x) = 1/2 x^T Q x + q^T x`` with full ``Q``.
+
+For a non-diagonal PSD ``Q`` the prox step is a single linear solve:
+
+    (Q + rho I) x = rho (z - y) - q
+
+Use :class:`~sheaf_admm.solvers.x_solvers.diagonal_prox.DiagonalProxXSolver`
+when ``Q`` is diagonal (the paper configs) — it is exact and avoids the solve.
+This solver covers low-rank / dense ``Q`` and is the natural extension point for
+richer local objectives.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import jax.numpy as jnp
+from flax import struct
+
+from sheaf_admm.solvers.base import XSolverParams, rho_as_vec
+
+
+@struct.dataclass
+class DenseQuadraticParams(XSolverParams):
+    pass
+
+
+class DenseQuadraticXSolver:
+    """Dense quadratic x-update. Reads ``Q`` ``[N,B,d,d]`` and ``q`` ``[N,B,d]``."""
+
+    @staticmethod
+    def solve(z, y, rho, encoder_output: dict[str, Any], params: DenseQuadraticParams):
+        Q = encoder_output["Q"]  # [N, B, d, d]
+        q = encoder_output["q"]  # [N, B, d]
+        d = Q.shape[-1]
+        rho_v = rho_as_vec(rho, z)  # scalar or [N, B, 1]
+        A = Q + rho_v[..., None] * jnp.eye(d, dtype=Q.dtype)
+        b = rho_v * (z - y) - q  # [N, B, d]
+        return jnp.linalg.solve(A, b[..., None]).squeeze(-1)
diff --git a/src/sheaf_admm/solvers/x_solvers/diagonal_prox.py b/src/sheaf_admm/solvers/x_solvers/diagonal_prox.py
new file mode 100644
index 0000000000000000000000000000000000000000..2882b0056f42b9319ff69497df5c1fbcf3350440
--- /dev/null
+++ b/src/sheaf_admm/solvers/x_solvers/diagonal_prox.py
@@ -0,0 +1,67 @@
+"""Unified diagonal proximal x-solver (closed form).
+
+A single closed form covers every diagonal local objective used in the paper.
+For a diagonal curvature ``D``, linear term ``q``, per-coordinate L1 weight
+``lambda``, and box ``[lo, hi]``:
+
+    v = z - y
+    a = D + l2 + rho
+    t = (rho * v - q) / a
+    x = clip( soft_threshold(t, lambda / a),  lo,  hi )
+
+Special cases (selected purely by what the encoder emits):
+
+* **quadratic** (``lambda=0``, no box): ``x = (rho v - q) / (D + rho)``.
+* **lasso** (scalar ``lambda``, no box): MNIST.
+* **non-negative** (``lambda=0``, ``lo=0``, ``hi=+inf``): Sudoku.
+* **L1 + box** (per-dim ``lambda``, ``lo=0``, per-dim ``hi``): Maze.
+
+This is exact — no inner iterations. All paper configs use diagonal ``Q``. The
+dense quadratic case is implemented separately in ``dense_quadratic.py`` for
+tests and code-level extensions.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import jax.numpy as jnp
+from flax import struct
+
+from sheaf_admm.solvers.base import XSolverParams, rho_as_vec, soft_threshold
+
+
+@struct.dataclass
+class DiagonalProxParams(XSolverParams):
+    """Fallback box bounds used only when the encoder does not emit them.
+
+    Defaults give an unconstrained problem (no box).
+    """
+
+    lower: float = -jnp.inf
+    upper: float = jnp.inf
+
+
+class DiagonalProxXSolver:
+    """Closed-form diagonal proximal x-update (see module docstring).
+
+    Reads from ``encoder_output``: ``q_diag`` ``[N,B,d]`` (diagonal curvature,
+    strictly positive), ``q`` ``[N,B,d]`` (linear term), and optionally
+    ``l1_weight`` ``[N,B,d]`` or scalar, ``l2_weight`` scalar, ``lower`` and
+    ``upper`` ``[N,B,d]`` or scalar.
+    """
+
+    @staticmethod
+    def solve(z, y, rho, encoder_output: dict[str, Any], params: DiagonalProxParams):
+        rho_v = rho_as_vec(rho, z)
+        diag = encoder_output["q_diag"]  # [N, B, d], > 0
+        q = encoder_output["q"]
+        l1 = encoder_output.get("l1_weight", 0.0)
+        l2 = encoder_output.get("l2_weight", 0.0)
+        lower = encoder_output.get("lower", params.lower)
+        upper = encoder_output.get("upper", params.upper)
+
+        a = diag + l2 + rho_v
+        t = (rho_v * (z - y) - q) / a
+        x = soft_threshold(t, l1 / a)
+        return jnp.clip(x, lower, upper)
diff --git a/src/sheaf_admm/solvers/x_solvers/experimental/__init__.py b/src/sheaf_admm/solvers/x_solvers/experimental/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ad87a920b98f40b5c3f5bc059f7bd6e5e1b72ee
--- /dev/null
+++ b/src/sheaf_admm/solvers/x_solvers/experimental/__init__.py
@@ -0,0 +1,10 @@
+"""Reserved namespace for non-paper x-solvers.
+
+The shipped configs use ``diagonal_prox`` from the public registry. This package
+is intentionally empty so downstream experiments can add custom constrained or
+dense-objective solvers without changing the default ADMM loop.
+"""
+
+from __future__ import annotations
+
+__all__: list[str] = []
diff --git a/src/sheaf_admm/solvers/x_solvers/simple.py b/src/sheaf_admm/solvers/x_solvers/simple.py
new file mode 100644
index 0000000000000000000000000000000000000000..4106aa23b0c46513e18c73bcbb6fa52e7c86e990
--- /dev/null
+++ b/src/sheaf_admm/solvers/x_solvers/simple.py
@@ -0,0 +1,31 @@
+"""Simple tether x-solver: ``f_i(x) = (beta/2) ||x - h||^2``.
+
+The cheapest local objective: each agent is pulled toward an encoder-produced
+target ``h`` with learned stiffness ``beta``. Closed form:
+
+    x = (beta * h + rho * (z - y)) / (beta + rho)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from flax import struct
+
+from sheaf_admm.solvers.base import XSolverParams, rho_as_vec
+
+
+@struct.dataclass
+class SimpleParams(XSolverParams):
+    pass
+
+
+class SimpleXSolver:
+    """Tether x-update. Reads ``h`` ``[N,B,d]`` and scalar ``beta`` from the encoder."""
+
+    @staticmethod
+    def solve(z, y, rho, encoder_output: dict[str, Any], params: SimpleParams):
+        rho_v = rho_as_vec(rho, z)
+        h = encoder_output["h"]
+        beta = encoder_output["beta"]
+        return (beta * h + rho_v * (z - y)) / (beta + rho_v)
diff --git a/src/sheaf_admm/solvers/z_solvers/__init__.py b/src/sheaf_admm/solvers/z_solvers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee4d41ef0627c20f7981ce72fbd590cb49e8e388
--- /dev/null
+++ b/src/sheaf_admm/solvers/z_solvers/__init__.py
@@ -0,0 +1,33 @@
+"""z-update solvers (sheaf consensus) and their registry.
+
+* ``unrolled_cg`` — fixed-``T`` conjugate gradient, the default z-solver.
+* ``gd`` — gradient descent with Nesterov momentum (the GD+Nesterov ablation).
+"""
+
+from __future__ import annotations
+
+from .gd import GDParams, GDZSolver
+from .unrolled_cg import UnrolledCGParams, UnrolledCGZSolver
+
+Z_SOLVERS = {
+    "unrolled_cg": (UnrolledCGZSolver, UnrolledCGParams),
+    "gd": (GDZSolver, GDParams),
+}
+
+
+def make_z_solver(name: str):
+    """Return ``(solver_cls, default_params)`` for a z-solver name."""
+    if name not in Z_SOLVERS:
+        raise KeyError(f"unknown z-solver {name!r}; available: {sorted(Z_SOLVERS)}")
+    cls, params_cls = Z_SOLVERS[name]
+    return cls, params_cls()
+
+
+__all__ = [
+    "Z_SOLVERS",
+    "make_z_solver",
+    "UnrolledCGZSolver",
+    "UnrolledCGParams",
+    "GDZSolver",
+    "GDParams",
+]
diff --git a/src/sheaf_admm/solvers/z_solvers/gd.py b/src/sheaf_admm/solvers/z_solvers/gd.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e695b4ddf69c7a8717b6b6a7e714d97d85becb6
--- /dev/null
+++ b/src/sheaf_admm/solvers/z_solvers/gd.py
@@ -0,0 +1,63 @@
+"""Gradient-descent z-solver (sheaf diffusion with Nesterov momentum).
+
+The alternative to CG for the consensus step, and the paper's "GD + Nesterov"
+z-update ablation. Runs a fixed number of accelerated gradient steps on the same
+objective CG solves:
+
+* ``project``: ``E(z) = E_sheaf(z)`` (minimized over the consensus directions).
+* ``prox``: ``E(z) = gamma * E_sheaf(z) + (rho/2) ||z - z_target||^2``.
+
+The step size ``eta`` is meta-learned (set per ADMM iteration by the loop). Each
+diffusion step ``z <- z - eta L_F z`` is a local message-passing operation.
+"""
+
+from __future__ import annotations
+
+import jax
+import jax.numpy as jnp
+import optax
+from flax import struct
+
+from sheaf_admm.geometry.base import SheafGeometry
+from sheaf_admm.solvers.base import ZSolverParams, rho_as_vec
+
+
+@struct.dataclass
+class GDParams(ZSolverParams):
+    num_steps: int = struct.field(pytree_node=False, default=10)
+    momentum: float = struct.field(pytree_node=False, default=0.9)
+    nesterov: bool = struct.field(pytree_node=False, default=True)
+    eta: jnp.ndarray = 0.01  # learned step size (dynamic; set per-iteration by the loop)
+
+
+class GDZSolver:
+    @staticmethod
+    def solve(z_target, z_prev, geometry: SheafGeometry, params: GDParams, rho):
+        gamma = jnp.asarray(params.gamma, dtype=z_target.dtype)
+        rho_v = rho_as_vec(rho, z_target)
+
+        if params.mode == "project":
+
+            def energy(z):
+                return geometry.energy(z)
+        elif params.mode == "prox":
+
+            def energy(z):
+                return gamma * geometry.energy(z) + 0.5 * jnp.sum(rho_v * (z - z_target) ** 2)
+        else:
+            raise ValueError(f"unknown z mode {params.mode!r} (project|prox)")
+
+        opt = optax.sgd(
+            learning_rate=params.eta, momentum=params.momentum, nesterov=params.nesterov
+        )
+        z0 = z_target
+        opt_state = opt.init(z0)
+
+        def step(carry, _):
+            z, state = carry
+            grad = jax.grad(energy)(z)
+            updates, state = opt.update(grad, state)
+            return (optax.apply_updates(z, updates), state), None
+
+        (z, _), _ = jax.lax.scan(step, (z0, opt_state), None, length=params.num_steps)
+        return z
diff --git a/src/sheaf_admm/solvers/z_solvers/unrolled_cg.py b/src/sheaf_admm/solvers/z_solvers/unrolled_cg.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a77fc1eca8c54d7b4ec02efc4de161e0e8d4b20
--- /dev/null
+++ b/src/sheaf_admm/solvers/z_solvers/unrolled_cg.py
@@ -0,0 +1,104 @@
+"""Unrolled conjugate-gradient z-solver (the paper's default consensus step).
+
+The z-update solves a PSD linear system in the sheaf Laplacian. We run a *fixed*
+number ``T`` of CG iterations and let gradients flow through every step via
+autodiff (explicit unroll, not implicit differentiation): implicit diff would
+require CG to have converged to give correct gradients, whereas the unrolled
+gradients capture the actual (under-solved) optimization trajectory the model is
+trained with — essential for meta-learning the restriction maps.
+
+Two modes:
+
+* ``project`` (hard consensus, ``F z = 0``): solve ``(L + eps I) w = L z_target``
+  and return ``z_target - w``. The tiny Tikhonov ``eps`` makes the singular ``L``
+  invertible (its kernel is the consensus subspace).
+* ``prox`` (soft consensus): solve ``(gamma L + rho I) z = rho z_target``.
+
+CG runs batched: each batch element is an independent system, so the inner
+products reduce over agents and stalk dims but keep the batch axis.
+"""
+
+from __future__ import annotations
+
+import jax
+import jax.numpy as jnp
+from flax import struct
+
+from sheaf_admm.geometry.base import SheafGeometry
+from sheaf_admm.solvers.base import ZSolverParams, rho_as_vec
+
+# CG denominator guard. 1e-8 (not 1e-12) because pTAp / rTr get small near
+# convergence and 1e-12 sits below float32 roundoff there, risking 0/0 -> NaN
+# in both the forward pass and the unrolled gradient. Distinct from the
+# project-mode Tikhonov ``tikhonov_eps`` below.
+_CG_DENOM_EPS = 1e-8
+
+
+@struct.dataclass
+class UnrolledCGParams(ZSolverParams):
+    num_iters: int = struct.field(pytree_node=False, default=5)  # T
+    tikhonov_eps: float = struct.field(pytree_node=False, default=1e-5)  # project-mode L+eps*I
+    prox_init: str = struct.field(pytree_node=False, default="legacy")  # "legacy" | "warm"
+    scan_unroll: int = struct.field(pytree_node=False, default=5)  # compile-time unroll, not T
+
+
+def _batched_cg(matvec, b, x0, num_iters, scan_unroll):
+    """Batched CG for ``A x = b`` over node states ``[N, B, d]``.
+
+    Inner products reduce over agents (axis 0) and stalk dim (axis 2), keeping
+    the batch axis -> per-batch scalars. ``num_iters`` is fixed (no early stop)
+    for consistent gradients.
+    """
+
+    def bdot(a, c):
+        return jnp.sum(a * c, axis=(0, 2))  # [B]
+
+    def bscale(s, v):
+        return s[None, :, None] * v  # [B] -> [1, B, 1]
+
+    r0 = b - matvec(x0)
+    p0 = r0
+    rTr0 = bdot(r0, r0)
+
+    def step(carry, _):
+        x, r, p, rTr = carry
+        Ap = matvec(p)
+        pTAp = bdot(p, Ap)
+        alpha = rTr / (pTAp + _CG_DENOM_EPS)
+        x = x + bscale(alpha, p)
+        r = r - bscale(alpha, Ap)
+        rTr_new = bdot(r, r)
+        beta = rTr_new / (rTr + _CG_DENOM_EPS)
+        p = r + bscale(beta, p)
+        return (x, r, p, rTr_new), None
+
+    (x, *_), _ = jax.lax.scan(step, (x0, r0, p0, rTr0), None, length=num_iters, unroll=scan_unroll)
+    return x
+
+
+class UnrolledCGZSolver:
+    @staticmethod
+    def solve(z_target, z_prev, geometry: SheafGeometry, params: UnrolledCGParams, rho):
+        if params.mode == "project":
+            eps = jnp.asarray(params.tikhonov_eps, dtype=z_target.dtype)
+            matvec = lambda x: geometry.laplacian_apply(x) + eps * x  # noqa: E731
+            b = geometry.laplacian_apply(z_target)
+            # Warm-start the correction at the ADMM target delta. This is the
+            # paper-run inexact hard-consensus path, not a standalone exact
+            # Euclidean projector: kernel components in the warm start are not
+            # removed by the RHS. Use zero/range-space initialization if exact
+            # projection idempotence is required.
+            w0 = z_target - z_prev
+            w = _batched_cg(matvec, b, w0, params.num_iters, params.scan_unroll)
+            return z_target - w
+
+        if params.mode == "prox":
+            gamma = jnp.asarray(params.gamma, dtype=z_target.dtype)
+            rho_v = rho_as_vec(rho, z_target)
+            matvec = lambda x: gamma * geometry.laplacian_apply(x) + rho_v * x  # noqa: E731
+            b = rho_v * z_target
+            # Detach the warm-start so it does not unroll the whole ADMM chain.
+            z0 = z_target if params.prox_init == "legacy" else jax.lax.stop_gradient(z_prev)
+            return _batched_cg(matvec, b, z0, params.num_iters, params.scan_unroll)
+
+        raise ValueError(f"unknown z mode {params.mode!r} (project|prox)")
diff --git a/src/sheaf_admm/training/__init__.py b/src/sheaf_admm/training/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..22dc6d4e3d6b12f3664ca25e800ff7e20488592b
--- /dev/null
+++ b/src/sheaf_admm/training/__init__.py
@@ -0,0 +1,29 @@
+"""Training: optimizer/EMA, task hooks, and the fit/eval loop."""
+
+from __future__ import annotations
+
+from .loop import (
+    build_model,
+    create_train_state,
+    evaluate,
+    make_train_step,
+    sample_k,
+)
+from .optim import TrainState, ema_update, eval_params, make_optimizer
+from .tasks import MazeTask, MNISTTask, SudokuTask, make_task
+
+__all__ = [
+    "build_model",
+    "create_train_state",
+    "make_train_step",
+    "evaluate",
+    "sample_k",
+    "TrainState",
+    "ema_update",
+    "eval_params",
+    "make_optimizer",
+    "make_task",
+    "MazeTask",
+    "MNISTTask",
+    "SudokuTask",
+]
diff --git a/src/sheaf_admm/training/loop.py b/src/sheaf_admm/training/loop.py
new file mode 100644
index 0000000000000000000000000000000000000000..e759c1d812e536096a2278527c7a5493b189d1fc
--- /dev/null
+++ b/src/sheaf_admm/training/loop.py
@@ -0,0 +1,163 @@
+"""Training loop: state creation, jitted steps, and the fit/eval driver.
+
+Handles both model families (Sheaf-ADMM and the MPNN baseline) and all tasks via
+the :mod:`sheaf_admm.training.tasks` hooks. The ADMM iteration count ``K`` is a
+static argument to the jitted step (so the per-step ``K ~ U[k_min, k_max]``
+resampling used for Maze training triggers one compile per distinct ``K``, then
+reuses the cache). Evaluation runs at ``K_eval`` on the EMA parameters.
+
+Tasks return ``(fwd, targets, aux)``; only ``fwd``/``targets`` (pure arrays) cross
+the ``jit`` boundary, ``aux`` (centers/image size) is used eager-side at eval.
+"""
+
+from __future__ import annotations
+
+from functools import partial
+
+import jax
+import numpy as np
+
+from sheaf_admm.models import ModelConfig, MPNNModel, SheafADMMModel
+
+from .optim import TrainState, ema_update, eval_params, init_ema, make_optimizer
+
+
+def build_model(config: ModelConfig, model_type: str):
+    if model_type == "sheaf":
+        return SheafADMMModel(config=config)
+    if model_type == "mpnn":
+        return MPNNModel(config=config)
+    raise ValueError(f"unknown model_type={model_type!r} (sheaf|mpnn)")
+
+
+def _forward(apply_fn, params, fwd, *, n_iter, loss_window, model_type, training, rng):
+    """Run the model to task logits.
+
+    Sheaf returns windowed per-agent logits ``[W,N,B,*out]``; MPNN returns
+    ``[N,B,*out]`` for per-node readouts or ``[B,C]`` for graph readouts.
+    """
+    rngs = {"dropout": rng} if (training and rng is not None) else None
+    if model_type == "sheaf":
+        logits_window, _state, _geom = apply_fn(
+            params,
+            fwd["patches"],
+            fwd["edge_indices"],
+            num_iters=n_iter,
+            loss_window=loss_window,
+            **fwd["model_kwargs"],
+            training=training,
+            rngs=rngs,
+        )
+        return logits_window
+    logits, _hidden = apply_fn(
+        params,
+        fwd["patches"],
+        fwd["edge_indices"],
+        num_rounds=n_iter,
+        **fwd["model_kwargs"],
+        training=training,
+        rngs=rngs,
+    )
+    return logits
+
+
+def create_train_state(
+    model,
+    sample_fwd,
+    *,
+    model_type,
+    lr,
+    weight_decay,
+    warmup_steps,
+    grad_clip,
+    ema_decay,
+    k_init,
+    loss_window,
+    seed,
+):
+    init_rng, dropout_rng = jax.random.split(jax.random.PRNGKey(seed))
+    rngs = {"params": init_rng, "dropout": dropout_rng}
+    kw = (
+        dict(num_iters=k_init, loss_window=loss_window)
+        if model_type == "sheaf"
+        else dict(num_rounds=k_init)
+    )
+    variables = model.init(
+        rngs,
+        sample_fwd["patches"],
+        sample_fwd["edge_indices"],
+        **kw,
+        **sample_fwd["model_kwargs"],
+        training=False,
+    )
+    tx = make_optimizer(lr, weight_decay, warmup_steps, grad_clip)
+    state = TrainState.create(apply_fn=model.apply, params=variables, tx=tx, ema_decay=ema_decay)
+    return init_ema(state)
+
+
+def make_train_step(task, model_type, graph_readout):
+    @partial(jax.jit, static_argnames=("n_iter", "loss_window"))
+    def train_step(state: TrainState, fwd, targets, dropout_rng, *, n_iter, loss_window):
+        def loss_fn(params):
+            logits = _forward(
+                state.apply_fn,
+                params,
+                fwd,
+                n_iter=n_iter,
+                loss_window=loss_window,
+                model_type=model_type,
+                training=True,
+                rng=dropout_rng,
+            )
+            if model_type == "mpnn" and graph_readout == "graph":
+                return task.loss_graph(logits, targets)
+            if model_type == "mpnn":
+                return task.loss(logits[None], targets)
+            return task.loss(logits, targets)
+
+        loss, grads = jax.value_and_grad(loss_fn)(state.params)
+        state = state.apply_gradients(grads=grads)
+        return ema_update(state), loss
+
+    return train_step
+
+
+def evaluate(state, task, batches, *, model_type, graph_readout, k_eval, max_batches=None):
+    """Eval at ``K_eval`` on EMA params; average task metrics over the split."""
+    params = eval_params(state)
+
+    @partial(jax.jit, static_argnames=("n_iter",))
+    def fwd_fn(params, fwd, *, n_iter):
+        return _forward(
+            state.apply_fn,
+            params,
+            fwd,
+            n_iter=n_iter,
+            loss_window=1,
+            model_type=model_type,
+            training=False,
+            rng=None,
+        )
+
+    agg: dict[str, float] = {}
+    n = 0
+    for batch in batches:
+        fwd, targets, aux = task.prepare(batch)
+        logits = fwd_fn(params, fwd, n_iter=k_eval)
+        final = logits if model_type == "mpnn" else logits[-1]
+        if model_type == "mpnn" and graph_readout == "graph":
+            m = task.evaluate_graph(final, targets, aux)
+        else:
+            m = task.evaluate(final, targets, aux)
+        for k, v in m.items():
+            agg[k] = agg.get(k, 0.0) + v
+        n += 1
+        if max_batches is not None and n >= max_batches:
+            break
+    return {k: v / max(n, 1) for k, v in agg.items()}
+
+
+def sample_k(rng_np: np.random.Generator, dist: str, k_min: int, k_max: int) -> int:
+    if dist != "uniform":
+        return k_max
+    return int(rng_np.integers(min(k_min, k_max), k_max + 1))
diff --git a/src/sheaf_admm/training/optim.py b/src/sheaf_admm/training/optim.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0573d40f7c089b177d6dfe480770f59e179780f
--- /dev/null
+++ b/src/sheaf_admm/training/optim.py
@@ -0,0 +1,74 @@
+"""Optimizer, learning-rate schedule, train state, and EMA.
+
+Matches the paper's shared optimization setup: AdamW, a 200-step linear warmup
+to a constant learning rate, global-norm gradient clipping at 1.0, and an
+exponential moving average of parameters (decay 0.999) used at evaluation.
+"""
+
+from __future__ import annotations
+
+import jax
+import jax.numpy as jnp
+import optax
+from flax import struct
+from flax.training import train_state
+
+
+def make_schedule(learning_rate: float, warmup_steps: int) -> optax.Schedule:
+    """Linear warmup ``0 -> lr`` over ``warmup_steps``, then constant ``lr``."""
+    if warmup_steps <= 0:
+        return optax.constant_schedule(learning_rate)
+    warmup = optax.linear_schedule(0.0, learning_rate, warmup_steps)
+    return optax.join_schedules(
+        [warmup, optax.constant_schedule(learning_rate)], boundaries=[warmup_steps]
+    )
+
+
+def make_optimizer(
+    learning_rate: float,
+    weight_decay: float = 0.0,
+    warmup_steps: int = 200,
+    grad_clip: float = 1.0,
+) -> optax.GradientTransformation:
+    """AdamW with warmup→constant LR; global-norm clip applied *before* the update."""
+    tx = optax.adamw(make_schedule(learning_rate, warmup_steps), weight_decay=weight_decay)
+    if grad_clip and grad_clip > 0:
+        tx = optax.chain(optax.clip_by_global_norm(grad_clip), tx)
+    return tx
+
+
+class TrainState(train_state.TrainState):
+    """Flax train state carrying an EMA shadow of the parameters.
+
+    ``ema_decay`` is a static field (so jit can branch on it). The EMA shadow is
+    initialized eagerly as a *copy* of the params in :func:`init_ema` — the copy
+    matters so the shadow never aliases a (possibly donated) live param buffer.
+    """
+
+    ema_params: optax.Params | None = None
+    ema_decay: float = struct.field(pytree_node=False, default=0.999)
+
+
+def init_ema(state: TrainState) -> TrainState:
+    """Eagerly seed the EMA shadow with a copy of the current params (if EMA on)."""
+    if state.ema_decay <= 0:
+        return state
+    return state.replace(ema_params=jax.tree_util.tree_map(jnp.copy, state.params))
+
+
+def ema_update(state: TrainState) -> TrainState:
+    """Update the EMA shadow: ``ema <- decay*ema + (1-decay)*params``."""
+    if state.ema_decay <= 0 or state.ema_params is None:
+        return state
+    d = state.ema_decay
+    new_ema = jax.tree_util.tree_map(
+        lambda e, p: d * e + (1.0 - d) * p, state.ema_params, state.params
+    )
+    return state.replace(ema_params=new_ema)
+
+
+def eval_params(state: TrainState):
+    """Parameters to evaluate with: the EMA shadow if active, else the live params."""
+    if state.ema_decay > 0 and state.ema_params is not None:
+        return state.ema_params
+    return state.params
diff --git a/src/sheaf_admm/training/tasks.py b/src/sheaf_admm/training/tasks.py
new file mode 100644
index 0000000000000000000000000000000000000000..3aebeb762d2de1372573dd17d30d0d301b48ad09
--- /dev/null
+++ b/src/sheaf_admm/training/tasks.py
@@ -0,0 +1,193 @@
+"""Task hooks: decomposition, loss, and evaluation per benchmark.
+
+A :class:`Task` turns a raw batch into three pieces (``prepare``):
+
+* ``fwd``    — model inputs (all arrays): ``patches``, ``edge_indices``, and
+  ``model_kwargs`` (graph extras the model needs: ``node_positions`` for grids,
+  ``map_u``/``map_v``/``cell_ids`` for Sudoku). Safe to pass through ``jit``.
+* ``targets`` — label arrays for the loss / metrics.
+* ``aux``    — non-jittable extras (agent centers, image size) used only for the
+  eager eval-time reassembly.
+
+``loss(logits_window, targets)`` scores the windowed per-agent logits;
+``evaluate(logits_final, targets, aux)`` reassembles the global prediction and
+returns task metrics. Adding a benchmark = adding a Task.
+"""
+
+from __future__ import annotations
+
+import jax
+import jax.numpy as jnp
+import optax
+
+from sheaf_admm.data import views as V
+
+PATH_TOKEN = 5  # maze: label token marking a path cell
+
+
+def _ce(logits, labels):
+    return optax.softmax_cross_entropy_with_integer_labels(logits, labels)
+
+
+def _windowed(loss_one, logits_window):
+    """Average a per-iterate loss over the ADMM loss window (axis 0)."""
+    return jnp.mean(jax.vmap(loss_one)(logits_window))
+
+
+def _grid_graph(image_hw, stride, patch_size, connectivity):
+    centers = V.grid_agent_centers(image_hw, stride=stride, patch_size=patch_size)
+    edge_indices = jnp.asarray(V.build_grid_edge_indices(centers, stride, connectivity))
+    return centers, edge_indices, V.node_positions(centers)
+
+
+class MazeTask:
+    name = "maze"
+
+    def __init__(self, *, patch_size=3, stride=2, connectivity=8, num_classes=6):
+        self.patch_size, self.stride, self.connectivity = patch_size, stride, connectivity
+        self.num_classes = num_classes
+
+    def prepare(self, batch):
+        inputs = jnp.asarray(batch["inputs"])
+        labels = jnp.asarray(batch["labels"])
+        B = inputs.shape[0]
+        H, W = V.infer_image_hw(inputs.shape[1], batch.get("height"), batch.get("width"))
+        inp_img, lab_img = inputs.reshape(B, H, W), labels.reshape(B, H, W)
+        centers, edges, npos = _grid_graph((H, W), self.stride, self.patch_size, self.connectivity)
+        patches = V.prepare_maze_patches(inp_img, centers, self.patch_size, self.num_classes)
+        label_patches, masks = V.get_agent_label_patches_jax(lab_img, centers, self.patch_size)
+        fwd = {"patches": patches, "edge_indices": edges, "model_kwargs": {"node_positions": npos}}
+        targets = {"label_patches": label_patches, "masks": masks, "labels_img": lab_img}
+        aux = {"centers": centers, "image_hw": (H, W)}
+        return fwd, targets, aux
+
+    def loss(self, logits_window, targets):
+        lp, masks = targets["label_patches"], targets["masks"]
+
+        def one(logits):
+            ce = _ce(logits, lp) * masks
+            return jnp.sum(ce) / jnp.maximum(jnp.sum(masks), 1.0)
+
+        return _windowed(one, logits_window)
+
+    def evaluate(self, logits_final, targets, aux):
+        recon = jnp.asarray(
+            V.reassemble_logits(
+                logits_final, aux["centers"], aux["image_hw"], self.num_classes, mode="mean"
+            )
+        )
+        pred = jnp.argmax(recon, axis=-1)
+        labels = targets["labels_img"]
+        solved = jnp.all((pred == PATH_TOKEN) == (labels == PATH_TOKEN), axis=(1, 2))
+        return {"solved": float(jnp.mean(solved)), "cell_acc": float(jnp.mean(pred == labels))}
+
+
+class MNISTTask:
+    name = "mnist"
+
+    def __init__(self, *, patch_size=3, stride=3, connectivity=8, num_classes=10):
+        self.patch_size, self.stride, self.connectivity, self.num_classes = (
+            patch_size,
+            stride,
+            connectivity,
+            num_classes,
+        )
+
+    def prepare(self, batch):
+        images = jnp.asarray(batch["images"])
+        labels = jnp.asarray(batch["labels"])
+        H, W = images.shape[1], images.shape[2]
+        centers, edges, npos = _grid_graph((H, W), self.stride, self.patch_size, self.connectivity)
+        patches = V.patchify_batch_jax(images, centers, self.patch_size)
+        model_kwargs = {"node_positions": npos}
+        keep_masks = batch.get("keep_masks")
+        if keep_masks is not None:
+            keep_masks = jnp.asarray(keep_masks, dtype=bool)
+            if keep_masks.shape != (images.shape[0], patches.shape[0]):
+                raise ValueError("keep_masks must be [B,N] for the realized MNIST agent graph")
+            u, v = edges[:, 0], edges[:, 1]
+            model_kwargs["edge_mask"] = jnp.transpose(keep_masks[:, u] & keep_masks[:, v])
+        fwd = {"patches": patches, "edge_indices": edges, "model_kwargs": model_kwargs}
+        return fwd, {"labels": labels}, {"keep_masks": keep_masks}
+
+    def loss(self, logits_window, targets):
+        labels = targets["labels"]
+
+        def one(logits):
+            return jnp.mean(_ce(logits, jnp.broadcast_to(labels, logits.shape[:-1])))
+
+        return _windowed(one, logits_window)
+
+    def loss_graph(self, logits, targets):  # MPNN graph readout [B,C]
+        return jnp.mean(_ce(logits, targets["labels"]))
+
+    def evaluate(self, logits_final, targets, aux):
+        probabilities = jax.nn.softmax(logits_final, axis=-1)
+        keep_masks = aux.get("keep_masks")
+        if keep_masks is None:
+            agg = jnp.mean(probabilities, axis=0)
+        else:
+            weights = jnp.transpose(keep_masks)[..., None]
+            agg = jnp.sum(probabilities * weights, axis=0) / jnp.maximum(
+                jnp.sum(weights, axis=0), 1
+            )
+        return {"acc": float(jnp.mean(jnp.argmax(agg, -1) == targets["labels"]))}
+
+    def evaluate_graph(self, logits, targets, aux):
+        return {"acc": float(jnp.mean(jnp.argmax(logits, -1) == targets["labels"]))}
+
+
+class SudokuTask:
+    name = "sudoku"
+    num_classes = 10
+
+    def prepare(self, batch):
+        inputs = jnp.asarray(batch["inputs"])
+        labels = jnp.asarray(batch["labels"])
+        B = inputs.shape[0]
+        inp, lab = inputs.reshape(B, 9, 9), labels.reshape(B, 9, 9)
+        edges, map_u, map_v = V.build_sudoku_multigraph(9)
+        cell_ids = V.build_sudoku_cell_indices(9)
+        patches = jnp.transpose(
+            V.sudoku_slice_batch_jax(jax.nn.one_hot(inp, self.num_classes)), (1, 0, 2, 3)
+        )
+        slice_labels = jnp.transpose(
+            V.sudoku_slice_batch_jax(lab[..., None])[..., 0], (1, 0, 2)
+        ).astype(jnp.int32)
+        fwd = {
+            "patches": patches,
+            "edge_indices": edges,
+            "model_kwargs": {"map_u": map_u, "map_v": map_v, "cell_ids": cell_ids},
+        }
+        targets = {
+            "slice_labels": slice_labels,
+            "labels_grid": lab.astype(jnp.int32),
+            "inputs_grid": inp.astype(jnp.int32),
+        }
+        return fwd, targets, {}
+
+    def loss(self, logits_window, targets):
+        labels = targets["slice_labels"]
+
+        def one(logits):
+            return jnp.mean(_ce(logits, labels))
+
+        return _windowed(one, logits_window)
+
+    def evaluate(self, logits_final, targets, aux):
+        recon = V.reassemble_sudoku_logits(jnp.transpose(logits_final, (1, 0, 2, 3)))
+        pred = jnp.argmax(recon, axis=-1)
+        labels = targets["labels_grid"]
+        empty = targets["inputs_grid"] == 0
+        return {
+            "cell_acc": float(jnp.mean(pred == labels)),
+            "solved": float(jnp.mean(jnp.all(pred == labels, axis=(1, 2)))),
+            "completion": float(jnp.sum((pred == labels) * empty) / jnp.maximum(jnp.sum(empty), 1)),
+        }
+
+
+def make_task(name: str, **kwargs):
+    tasks = {"maze": MazeTask, "mnist": MNISTTask, "sudoku": SudokuTask}
+    if name not in tasks:
+        raise KeyError(f"unknown task {name!r}; available: {sorted(tasks)}")
+    return tasks[name](**kwargs)
diff --git a/src/sheaf_admm/viz/__init__.py b/src/sheaf_admm/viz/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..124196e96e93dc631b4c8ec08d8c2b56be80753d
--- /dev/null
+++ b/src/sheaf_admm/viz/__init__.py
@@ -0,0 +1,31 @@
+"""Visualization: turn a trained Sheaf-ADMM model into the paper's analysis artifacts.
+
+Three static-image artifacts, all matplotlib (Agg backend), all driven off the
+:mod:`sheaf_admm.training.tasks` ``prepare`` outputs:
+
+* :func:`plot_prediction_evolution` (fig 3/4/5) — the aggregated global
+  prediction at increasing ADMM iteration counts ``k``.
+* :func:`plot_coordination_dynamics` (fig 4) — per-agent primal/dual residual
+  heatmaps and the mean/max convergence curves.
+* :func:`plot_xz_trajectories` (fig 7) — per-agent local proposal ``x`` vs
+  consensus ``z`` 2-D trajectories on the agent grid.
+
+The latter two consume a :class:`~sheaf_admm.viz.trajectory.Trajectory` built by
+:func:`run_trajectory`, which records the full per-iteration ADMM path on a
+single example.
+"""
+
+from __future__ import annotations
+
+from .coordination import plot_coordination_dynamics
+from .prediction import plot_prediction_evolution
+from .trajectory import Trajectory, run_trajectory
+from .xz import plot_xz_trajectories
+
+__all__ = [
+    "Trajectory",
+    "run_trajectory",
+    "plot_prediction_evolution",
+    "plot_coordination_dynamics",
+    "plot_xz_trajectories",
+]
diff --git a/src/sheaf_admm/viz/_render.py b/src/sheaf_admm/viz/_render.py
new file mode 100644
index 0000000000000000000000000000000000000000..8246a7de7e507a89d84a2b335799c37dc389c57b
--- /dev/null
+++ b/src/sheaf_admm/viz/_render.py
@@ -0,0 +1,150 @@
+"""Low-level matplotlib rendering helpers shared by the artifact modules.
+
+Single-axis panel renderers (no figure management) plus a figure-save helper that
+infers the format from the path suffix. Kept deliberately plain — clean grids,
+muted palettes, no styling state the caller has to reset — so the higher-level
+``plot_*`` functions just lay out a grid of these.
+"""
+
+from __future__ import annotations
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.colors import BoundaryNorm, ListedColormap
+
+
+def save_figure(fig, out_path: str, *, dpi: int = 150) -> None:
+    """Tight-layout and write ``fig`` to ``out_path`` (PNG/PDF by suffix), then close it."""
+    fig.tight_layout()
+    fig.savefig(out_path, dpi=dpi, bbox_inches="tight")
+    plt.close(fig)
+
+
+def _blank_axis(ax) -> None:
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+# =============================================================================
+# Maze
+# =============================================================================
+
+
+def render_maze_panel(ax, maze_img, pred, wall, start, goal, path_token) -> None:
+    """Grayscale maze with the predicted path overlaid in blue.
+
+    ``maze_img``: ``[H, W]`` ground-truth/label tokens (walls vs free space).
+    ``pred``: ``[H, W]`` predicted tokens; cells equal to ``path_token`` are the
+    predicted path. Start / goal cells get green / red markers.
+    """
+    maze_img = np.asarray(maze_img)
+    pred = np.asarray(pred)
+    base = np.where(maze_img == wall, 0.15, 1.0)  # walls dark, free space light
+    ax.imshow(base, cmap="gray", vmin=0.0, vmax=1.0, interpolation="nearest")
+
+    path = pred == path_token
+    overlay = np.zeros((*path.shape, 4), dtype=np.float32)
+    overlay[path] = (0.10, 0.35, 0.85, 0.85)  # blue, semi-opaque
+    ax.imshow(overlay, interpolation="nearest")
+
+    for token, color in ((start, "#16a34a"), (goal, "#dc2626")):
+        ys, xs = np.where(maze_img == token)
+        ax.scatter(xs, ys, s=42, c=color, marker="s", edgecolors="white", linewidths=0.6, zorder=3)
+    _blank_axis(ax)
+
+
+# =============================================================================
+# Sudoku
+# =============================================================================
+
+
+def sudoku_violations(pred: np.ndarray) -> np.ndarray:
+    """Boolean ``[9, 9]`` mask of cells whose digit repeats in its row, column, or box."""
+    pred = np.asarray(pred)
+    viol = np.zeros((9, 9), dtype=bool)
+
+    def mark(cells):
+        # cells: list of (r, c); flag any digit (1-9) appearing more than once.
+        vals = [pred[r, c] for r, c in cells]
+        for d in range(1, 10):
+            idx = [i for i, v in enumerate(vals) if v == d]
+            if len(idx) > 1:
+                for i in idx:
+                    r, c = cells[i]
+                    viol[r, c] = True
+
+    for r in range(9):
+        mark([(r, c) for c in range(9)])
+    for c in range(9):
+        mark([(r, c) for r in range(9)])
+    for br in range(0, 9, 3):
+        for bc in range(0, 9, 3):
+            mark([(br + i, bc + j) for i in range(3) for j in range(3)])
+    return viol
+
+
+def render_sudoku_panel(ax, givens, pred) -> None:
+    """9x9 Sudoku board: given clues black, filled digits blue, violations red-shaded.
+
+    ``givens``: ``[9, 9]`` input grid (0 = empty). ``pred``: ``[9, 9]`` predicted
+    digits (1-9; 0 left blank).
+    """
+    givens = np.asarray(givens)
+    pred = np.asarray(pred)
+    viol = sudoku_violations(pred)
+
+    ax.set_xlim(0, 9)
+    ax.set_ylim(0, 9)
+    ax.invert_yaxis()
+    ax.set_aspect("equal")
+
+    # Violation shading behind the digits.
+    for r in range(9):
+        for c in range(9):
+            if viol[r, c]:
+                ax.add_patch(plt.Rectangle((c, r), 1, 1, color="#fca5a5", zorder=0))
+
+    # Grid lines: thin for cells, thick for 3x3 boxes.
+    for i in range(10):
+        lw = 2.0 if i % 3 == 0 else 0.5
+        ax.plot([i, i], [0, 9], color="black", lw=lw, zorder=1)
+        ax.plot([0, 9], [i, i], color="black", lw=lw, zorder=1)
+
+    for r in range(9):
+        for c in range(9):
+            d = int(pred[r, c])
+            if d == 0:
+                continue
+            given = int(givens[r, c]) != 0
+            color = "black" if given else "#1d4ed8"
+            weight = "bold" if given else "normal"
+            ax.text(
+                c + 0.5,
+                r + 0.5,
+                str(d),
+                ha="center",
+                va="center",
+                fontsize=11,
+                color=color,
+                fontweight=weight,
+                zorder=2,
+            )
+    _blank_axis(ax)
+
+
+# =============================================================================
+# MNIST (per-pixel class consensus)
+# =============================================================================
+
+_MNIST_CMAP = ListedColormap(plt.get_cmap("tab10").colors)
+
+
+def render_mnist_panel(ax, pred, num_classes: int = 10) -> None:
+    """Per-pixel argmax-class consensus heatmap (``[H, W]`` class ids in ``tab10``)."""
+    pred = np.asarray(pred)
+    norm = BoundaryNorm(np.arange(-0.5, num_classes + 0.5, 1.0), num_classes)
+    ax.imshow(pred, cmap=_MNIST_CMAP, norm=norm, interpolation="nearest")
+    _blank_axis(ax)
diff --git a/src/sheaf_admm/viz/coordination.py b/src/sheaf_admm/viz/coordination.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c0482f457c74975db568d8376d4db2946ffa52a
--- /dev/null
+++ b/src/sheaf_admm/viz/coordination.py
@@ -0,0 +1,85 @@
+"""Coordination-dynamics artifact (paper fig 4).
+
+Visualizes how the ADMM residuals decay as the agents coordinate, from a single
+:class:`~sheaf_admm.viz.trajectory.Trajectory`:
+
+* two ``[N, K]`` heatmaps (agents x iteration) of the per-agent **primal**
+  residual ``||x_i - z_i||`` and **dual** residual ``rho ||z_i - z_prev_i||``;
+* a curves panel with the mean and max over agents of each residual, plus the
+  sheaf-consistency RMS, on a log y-axis.
+
+This is the convergence story: residuals start large and decay toward the
+consensus fixed point.
+"""
+
+from __future__ import annotations
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.colors import LogNorm
+
+from ._render import save_figure
+from .trajectory import Trajectory
+
+
+def _heatmap(ax, data_nk, title, cmap):
+    """``data_nk``: ``[N, K]`` per-agent-over-iteration residual heatmap.
+
+    Residuals routinely span several orders of magnitude (a large iteration-0
+    transient collapsing to a small steady state), so the color scale is
+    logarithmic, floored at the smallest positive entry to keep zeros finite.
+    """
+    pos = data_nk[data_nk > 0]
+    vmin = float(pos.min()) if pos.size else 1e-12
+    vmax = float(data_nk.max()) if data_nk.size else 1.0
+    norm = LogNorm(vmin=vmin, vmax=max(vmax, vmin * 10))
+    im = ax.imshow(
+        np.maximum(data_nk, vmin),
+        aspect="auto",
+        cmap=cmap,
+        interpolation="nearest",
+        origin="lower",
+        norm=norm,
+    )
+    ax.set_title(title, fontsize=11)
+    ax.set_xlabel("ADMM iteration k")
+    ax.set_ylabel("agent i")
+    plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+
+
+def plot_coordination_dynamics(traj: Trajectory, out_path: str, *, title: str | None = None):
+    """Render the primal/dual residual heatmaps and the mean/max curves.
+
+    ``traj`` is a :class:`~sheaf_admm.viz.trajectory.Trajectory` (one example).
+    Writes the figure to ``out_path``.
+    """
+    primal = traj.primal_res  # [K, N]
+    dual = traj.dual_res  # [K, N]
+    crms = traj.consistency_rms  # [K]
+    ks = np.arange(1, traj.num_iters + 1)
+
+    fig, axes = plt.subplots(1, 3, figsize=(13.5, 3.8))
+
+    _heatmap(axes[0], primal.T, "primal residual  ||x_i - z_i||", "viridis")
+    _heatmap(axes[1], dual.T, r"dual residual  $\rho\,||z_i - z^{-}_i||$", "magma")
+
+    ax = axes[2]
+    ax.plot(ks, primal.mean(axis=1), color="#1d4ed8", label="primal (mean)")
+    ax.plot(ks, primal.max(axis=1), color="#1d4ed8", ls="--", alpha=0.6, label="primal (max)")
+    ax.plot(ks, dual.mean(axis=1), color="#dc2626", label="dual (mean)")
+    ax.plot(ks, dual.max(axis=1), color="#dc2626", ls="--", alpha=0.6, label="dual (max)")
+    ax.plot(ks, crms, color="#16a34a", label="consistency RMS")
+    ax.set_yscale("log")
+    ax.set_xlabel("ADMM iteration k")
+    ax.set_ylabel("residual (log)")
+    ax.set_title("convergence", fontsize=11)
+    ax.legend(fontsize=7, loc="upper right")
+    ax.grid(True, which="both", alpha=0.2)
+
+    if title:
+        fig.suptitle(title, fontsize=12)
+    save_figure(fig, out_path)
+    return out_path
diff --git a/src/sheaf_admm/viz/prediction.py b/src/sheaf_admm/viz/prediction.py
new file mode 100644
index 0000000000000000000000000000000000000000..99da6b3c408113648e788cf76a601460fcb0ffba
--- /dev/null
+++ b/src/sheaf_admm/viz/prediction.py
@@ -0,0 +1,152 @@
+"""Prediction-evolution artifacts (paper fig 3/4/5).
+
+Renders the aggregated global prediction at increasing ADMM iteration counts
+``k`` to show coordination sharpening the answer. For each ``k`` we run the
+model with ``num_iters=k`` (``loss_window=1``, take the final x-iterate),
+reassemble the per-agent logit patches into a global grid, and render one panel
+per ``k`` in a row.
+
+Per task:
+
+* **Maze** — blue path overlay (predicted ``path`` token) on the grayscale maze,
+  with start/goal markers.
+* **Sudoku** — the 9x9 board with given clues (black) and filled digits (blue),
+  constraint-violating cells highlighted red.
+* **MNIST** — per-pixel argmax-class consensus as a discrete heatmap.
+"""
+
+from __future__ import annotations
+
+import jax.numpy as jnp
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+from sheaf_admm.data import views as V
+from sheaf_admm.data.common import TOKEN_IDS
+
+from ._render import (
+    render_maze_panel,
+    render_mnist_panel,
+    render_sudoku_panel,
+    save_figure,
+)
+
+
+def _final_logits(model, params, fwd, k):
+    """Per-agent logits at the last x-iterate of a ``k``-iteration run: ``[N, B, *out]``."""
+    logits_window, _state, _geom = model.apply(
+        params,
+        fwd["patches"],
+        fwd["edge_indices"],
+        num_iters=int(k),
+        loss_window=1,
+        **fwd["model_kwargs"],
+        training=False,
+    )
+    return logits_window[-1]
+
+
+def _maze_predictions(model, params, fwd, aux, ks, batch_index):
+    centers, image_hw = aux["centers"], aux["image_hw"]
+    preds = []
+    for k in ks:
+        logits = np.asarray(_final_logits(model, params, fwd, k))  # [N, B, ph, pw, C]
+        recon = V.reassemble_logits(
+            logits, np.asarray(centers), image_hw, logits.shape[-1], mode="mean"
+        )
+        preds.append(np.argmax(recon[batch_index], axis=-1))
+    return preds, image_hw
+
+
+def _sudoku_predictions(model, params, fwd, ks, batch_index):
+    preds = []
+    for k in ks:
+        logits = _final_logits(model, params, fwd, k)  # [N, B, 9, 10]
+        recon = V.reassemble_sudoku_logits(jnp.transpose(logits, (1, 0, 2, 3)))  # [B, 9, 9, 10]
+        preds.append(np.argmax(np.asarray(recon[batch_index]), axis=-1))
+    return preds
+
+
+def _mnist_grid(task, fwd):
+    """Recompute the MNIST agent ``(centers, image_hw)`` (the task's ``aux`` is empty)."""
+    ph = int(fwd["patches"].shape[2])
+    # The padded image side is recoverable from the agent count and stride.
+    n_per_side = int(round(np.sqrt(fwd["patches"].shape[0])))
+    # First center is at patch_size//2; centers step by stride.
+    side = (ph // 2) + (n_per_side - 1) * task.stride + 1
+    centers = V.grid_agent_centers((side, side), stride=task.stride, patch_size=ph)
+    return centers, (side, side)
+
+
+def _mnist_predictions(model, params, task, fwd, ks, batch_index):
+    centers, image_hw = _mnist_grid(task, fwd)
+    preds = []
+    for k in ks:
+        logits = _final_logits(model, params, fwd, k)  # [N, B, ph, pw, C] or [N, B, C]
+        logits = np.asarray(logits)
+        if logits.ndim == 5:
+            recon = V.reassemble_logits(
+                logits, np.asarray(centers), image_hw, logits.shape[-1], mode="mean"
+            )
+            preds.append(("pixel", np.argmax(recon[batch_index], axis=-1)))
+        else:
+            # Classification head: one class per agent. Render the per-agent argmax
+            # over the agent lattice (the spatial class-consensus map).
+            n_per_side = int(round(np.sqrt(logits.shape[0])))
+            grid = np.argmax(logits[:, batch_index], axis=-1).reshape(n_per_side, n_per_side)
+            preds.append(("agent", grid))
+    return preds
+
+
+def plot_prediction_evolution(
+    model,
+    params,
+    task,
+    fwd: dict,
+    targets: dict,
+    aux: dict,
+    ks,
+    out_path: str,
+    *,
+    batch_index: int = 0,
+    title: str | None = None,
+):
+    """Render the aggregated prediction at each ADMM count ``k`` as a one-row panel.
+
+    ``task`` is the :mod:`sheaf_admm.training.tasks` hook (its ``.name`` selects
+    the renderer). ``fwd``/``targets``/``aux`` are its ``prepare`` output. Writes
+    the figure to ``out_path``.
+    """
+    ks = list(ks)
+    task_name = task.name
+    fig, axes = plt.subplots(1, len(ks), figsize=(2.6 * len(ks), 2.9), squeeze=False)
+    axes = axes[0]
+
+    if task_name == "maze":
+        preds, _image_hw = _maze_predictions(model, params, fwd, aux, ks, batch_index)
+        maze_img = np.asarray(targets["labels_img"][batch_index])
+        wall, start, goal = TOKEN_IDS["wall"], TOKEN_IDS["start"], TOKEN_IDS["goal"]
+        for ax, k, pred in zip(axes, ks, preds, strict=True):
+            render_maze_panel(ax, maze_img, pred, wall, start, goal, TOKEN_IDS["path"])
+            ax.set_title(f"k = {k}", fontsize=11)
+    elif task_name == "sudoku":
+        preds = _sudoku_predictions(model, params, fwd, ks, batch_index)
+        givens = np.asarray(targets["inputs_grid"][batch_index])
+        for ax, k, pred in zip(axes, ks, preds, strict=True):
+            render_sudoku_panel(ax, givens, pred)
+            ax.set_title(f"k = {k}", fontsize=11)
+    elif task_name == "mnist":
+        preds = _mnist_predictions(model, params, task, fwd, ks, batch_index)
+        for ax, k, (_kind, pred) in zip(axes, ks, preds, strict=True):
+            render_mnist_panel(ax, pred, num_classes=task.num_classes)
+            ax.set_title(f"k = {k}", fontsize=11)
+    else:
+        raise ValueError(f"unknown task name {task_name!r} (maze|sudoku|mnist)")
+
+    if title:
+        fig.suptitle(title, fontsize=12)
+    save_figure(fig, out_path)
+    return out_path
diff --git a/src/sheaf_admm/viz/trajectory.py b/src/sheaf_admm/viz/trajectory.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f9fcd8487f8330f79b63e6787dc69d64fd2b045
--- /dev/null
+++ b/src/sheaf_admm/viz/trajectory.py
@@ -0,0 +1,94 @@
+"""Run the ADMM coordinator and capture its per-iteration trajectory.
+
+A thin, host-side wrapper around
+:meth:`sheaf_admm.models.SheafADMMModel.coordinate_history`. It runs the forward
+pass on a single (or small) batch and packs the result into a NumPy
+:class:`Trajectory` the plotting modules consume — agent states ``x^k``/``z^k``,
+the primal/dual residuals, the sheaf-consistency RMS, the per-iterate decoded
+logits, and the (static) agent graph. Everything is pulled to host as NumPy so
+the plotting code never touches JAX.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import jax
+import numpy as np
+
+from sheaf_admm.models import SheafADMMModel
+
+
+@dataclass
+class Trajectory:
+    """Host-side ADMM trajectory for one example (batch index already selected).
+
+    Shapes (``K`` iterations, ``N`` agents, ``d_v`` stalk):
+
+    * ``x``, ``z``, ``y``: ``[K, N, d_v]`` per-agent iterates.
+    * ``primal_res``, ``dual_res``: ``[K, N]`` per-agent residuals.
+    * ``consistency_rms``: ``[K]`` sheaf-disagreement RMS.
+    * ``logits``: ``[K, N, *out]`` per-iterate decoded per-agent logits.
+    * ``edge_indices``: ``[E, 2]`` agent graph (``u, v``).
+    * ``centers``: ``[N, 2]`` agent ``(y, x)`` grid centers, or ``None`` (Sudoku).
+    * ``rho``: the learned ADMM penalty (scalar).
+    """
+
+    x: np.ndarray
+    z: np.ndarray
+    y: np.ndarray
+    primal_res: np.ndarray
+    dual_res: np.ndarray
+    consistency_rms: np.ndarray
+    logits: np.ndarray
+    edge_indices: np.ndarray
+    centers: np.ndarray | None
+    rho: float
+
+    @property
+    def num_iters(self) -> int:
+        return int(self.x.shape[0])
+
+    @property
+    def num_agents(self) -> int:
+        return int(self.x.shape[1])
+
+
+def run_trajectory(
+    model: SheafADMMModel,
+    params,
+    fwd: dict,
+    *,
+    num_iters: int,
+    batch_index: int = 0,
+    centers: np.ndarray | None = None,
+) -> Trajectory:
+    """Run ``num_iters`` ADMM steps and return the host-side :class:`Trajectory`.
+
+    ``fwd`` is a task ``prepare`` output (``patches``, ``edge_indices``,
+    ``model_kwargs``). The trajectory is sliced to ``batch_index`` on the batch
+    axis. ``centers`` (the grid task's agent centers, from ``aux``) is carried
+    through for spatial layout; pass ``None`` for Sudoku.
+    """
+    history, logits_per_iter, _final, _geom, rho = model.apply(
+        params,
+        fwd["patches"],
+        fwd["edge_indices"],
+        num_iters=num_iters,
+        **fwd["model_kwargs"],
+        training=False,
+        method=SheafADMMModel.coordinate_history,
+    )
+    b = batch_index
+    return Trajectory(
+        x=np.asarray(history.x[:, :, b]),
+        z=np.asarray(history.z[:, :, b]),
+        y=np.asarray(history.y[:, :, b]),
+        primal_res=np.asarray(history.primal_res[:, :, b]),
+        dual_res=np.asarray(history.dual_res[:, :, b]),
+        consistency_rms=np.asarray(history.consistency_rms[:, b]),
+        logits=np.asarray(logits_per_iter[:, :, b]),
+        edge_indices=np.asarray(jax.device_get(fwd["edge_indices"])),
+        centers=None if centers is None else np.asarray(centers),
+        rho=float(rho),
+    )
diff --git a/src/sheaf_admm/viz/xz.py b/src/sheaf_admm/viz/xz.py
new file mode 100644
index 0000000000000000000000000000000000000000..67aec977186582570123c747af1bfa6bf3d5b943
--- /dev/null
+++ b/src/sheaf_admm/viz/xz.py
@@ -0,0 +1,113 @@
+"""x-vs-z trajectory artifact (paper fig 7).
+
+For each agent, plot the local proposal ``x_i^k`` (blue) and the consensus
+iterate ``z_i^k`` (red) across ADMM iterations ``k``, as a small per-agent
+2-D phase portrait. The panels are laid out on the agent grid (grid tasks use
+the actual ``(y, x)`` centers; Sudoku falls back to a square index grid).
+
+When the stalk dimension ``d_v > 2`` the iterates are projected to 2-D with a
+single PCA basis fit jointly over *all* agents' ``x`` and ``z`` across all
+iterations, so the panels share one coordinate frame and are comparable. The
+shared frame is the point: as ADMM converges, each agent's blue ``x`` and red
+``z`` paths should collapse onto a common point.
+"""
+
+from __future__ import annotations
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+from ._render import save_figure
+from .trajectory import Trajectory
+
+
+def _pca_basis(points: np.ndarray):
+    """Fit a 2-component PCA on ``[M, d]`` points; return ``(mean [d], components [d, 2])``."""
+    mean = points.mean(axis=0)
+    centered = points - mean
+    # SVD of the centered data; right-singular vectors are the principal axes.
+    _u, _s, vt = np.linalg.svd(centered, full_matrices=False)
+    comps = vt[:2].T  # [d, 2]
+    return mean, comps
+
+
+def _project(traj: Trajectory):
+    """Project ``x``/``z`` (``[K, N, d_v]``) to 2-D. Returns ``(x2 [K,N,2], z2 [K,N,2])``."""
+    K, N, d = traj.x.shape
+    if d == 2:
+        return traj.x.copy(), traj.z.copy()
+    if d == 1:
+        zeros_x = np.zeros((K, N, 1), dtype=traj.x.dtype)
+        zeros_z = np.zeros((K, N, 1), dtype=traj.z.dtype)
+        return np.concatenate([traj.x, zeros_x], -1), np.concatenate([traj.z, zeros_z], -1)
+    stacked = np.concatenate([traj.x.reshape(-1, d), traj.z.reshape(-1, d)], axis=0)
+    mean, comps = _pca_basis(stacked)
+    x2 = ((traj.x.reshape(-1, d) - mean) @ comps).reshape(K, N, 2)
+    z2 = ((traj.z.reshape(-1, d) - mean) @ comps).reshape(K, N, 2)
+    return x2, z2
+
+
+def _grid_layout(traj: Trajectory):
+    """Map each agent to a ``(row, col)`` subplot slot and return ``(nrows, ncols, slots)``."""
+    N = traj.num_agents
+    if traj.centers is not None:
+        ys = np.unique(traj.centers[:, 0])
+        xs = np.unique(traj.centers[:, 1])
+        row_of = {v: i for i, v in enumerate(ys)}
+        col_of = {v: i for i, v in enumerate(xs)}
+        slots = [(row_of[int(c[0])], col_of[int(c[1])]) for c in traj.centers]
+        return len(ys), len(xs), slots
+    ncols = int(np.ceil(np.sqrt(N)))
+    nrows = int(np.ceil(N / ncols))
+    slots = [(i // ncols, i % ncols) for i in range(N)]
+    return nrows, ncols, slots
+
+
+def plot_xz_trajectories(traj: Trajectory, out_path: str, *, title: str | None = None):
+    """Render the per-agent x (blue) vs z (red) 2-D trajectory grid.
+
+    ``traj`` is a :class:`~sheaf_admm.viz.trajectory.Trajectory` (one example).
+    Writes the figure to ``out_path``.
+    """
+    x2, z2 = _project(traj)  # [K, N, 2]
+    nrows, ncols, slots = _grid_layout(traj)
+
+    fig, axes = plt.subplots(nrows, ncols, figsize=(1.7 * ncols, 1.7 * nrows), squeeze=False)
+    for ax_row in axes:
+        for ax in ax_row:
+            ax.set_visible(False)
+
+    # Shared axis limits across panels so trajectories are comparable.
+    allpts = np.concatenate([x2.reshape(-1, 2), z2.reshape(-1, 2)], axis=0)
+    lo, hi = allpts.min(axis=0), allpts.max(axis=0)
+    pad = 0.05 * np.maximum(hi - lo, 1e-6)
+    lo, hi = lo - pad, hi + pad
+
+    for a, (r, col) in enumerate(slots):
+        ax = axes[r][col]
+        ax.set_visible(True)
+        ax.plot(x2[:, a, 0], x2[:, a, 1], color="#1d4ed8", lw=1.0, marker="o", ms=2.0, label="x")
+        ax.plot(z2[:, a, 0], z2[:, a, 1], color="#dc2626", lw=1.0, marker="o", ms=2.0, label="z")
+        # Mark the start (open) and end (filled) of the consensus path.
+        ax.scatter(
+            z2[0, a, 0], z2[0, a, 1], facecolors="none", edgecolors="#dc2626", s=22, zorder=3
+        )
+        ax.scatter(z2[-1, a, 0], z2[-1, a, 1], color="#111827", s=18, zorder=3)
+        ax.set_xlim(lo[0], hi[0])
+        ax.set_ylim(lo[1], hi[1])
+        ax.set_xticks([])
+        ax.set_yticks([])
+        ax.set_title(f"agent {a}", fontsize=6)
+
+    handles = [
+        plt.Line2D([], [], color="#1d4ed8", marker="o", ms=3, label="x (local)"),
+        plt.Line2D([], [], color="#dc2626", marker="o", ms=3, label="z (consensus)"),
+    ]
+    fig.legend(handles=handles, loc="lower center", ncol=2, fontsize=9)
+    if title:
+        fig.suptitle(title, fontsize=12)
+    save_figure(fig, out_path)
+    return out_path
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000000000000000000000000000000000000..59e227757e593156a1b07fa818a27843941e7131
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,1645 @@
+version = 1
+revision = 3
+requires-python = "==3.12.*"
+resolution-markers = [
+    "python_version < '0'",
+    "sys_platform == 'win32'",
+    "sys_platform == 'emscripten'",
+    "sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32'",
+    "sys_platform == 'linux'",
+]
+
+[[package]]
+name = "absl-py"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/64/c7/8de93764ad66968d19329a7e0c147a2bb3c7054c554d4a119111b8f9440f/absl_py-2.4.0.tar.gz", hash = "sha256:8c6af82722b35cf71e0f4d1d47dcaebfff286e27110a99fc359349b247dfb5d4", size = 116543, upload-time = "2026-01-28T10:17:05.322Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/a6/907a406bb7d359e6a63f99c313846d9eec4f7e6f7437809e03aa00fa3074/absl_py-2.4.0-py3-none-any.whl", hash = "sha256:88476fd881ca8aab94ffa78b7b6c632a782ab3ba1cd19c9bd423abc4fb4cd28d", size = 135750, upload-time = "2026-01-28T10:17:04.19Z" },
+]
+
+[[package]]
+name = "aiofiles"
+version = "25.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/41/c3/534eac40372d8ee36ef40df62ec129bee4fdb5ad9706e58a29be53b2c970/aiofiles-25.1.0.tar.gz", hash = "sha256:a8d728f0a29de45dc521f18f07297428d56992a742f0cd2701ba86e44d23d5b2", size = 46354, upload-time = "2025-10-09T20:51:04.358Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/8a/340a1555ae33d7354dbca4faa54948d76d89a27ceef032c8c3bc661d003e/aiofiles-25.1.0-py3-none-any.whl", hash = "sha256:abe311e527c862958650f9438e859c1fa7568a141b22abcd015e120e86a85695", size = 14668, upload-time = "2025-10-09T20:51:03.174Z" },
+]
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/33/c6/61a2d7b7572279226bb2e7f61d7a19ca7c90da0329c93fa0d560cbf288d8/aiohappyeyeballs-2.6.2.tar.gz", hash = "sha256:e202810ee718bd01fc6ef49e8ea53d023d5cb6b581076d7925aa499fa55dbe64", size = 22591, upload-time = "2026-05-20T15:12:24.631Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/fc/a7bf5b6e4e617b45f90f2d9d2a68519c249c81dd4fc2658c7a2a61c4f4b7/aiohappyeyeballs-2.6.2-py3-none-any.whl", hash = "sha256:4708045e2d7a6c6bdf8aafa8ed39649eaf926a4543b54560659129e3365953c4", size = 15062, upload-time = "2026-05-20T15:12:23.328Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/77/9a/152096d4808df8e4268befa55fba462f440f14beab85e8ad9bf990516918/aiohttp-3.13.5.tar.gz", hash = "sha256:9d98cc980ecc96be6eb4c1994ce35d28d8b1f5e5208a23b421187d1209dbb7d1", size = 7858271, upload-time = "2026-03-31T22:01:03.343Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/6f/353954c29e7dcce7cf00280a02c75f30e133c00793c7a2ed3776d7b2f426/aiohttp-3.13.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:023ecba036ddd840b0b19bf195bfae970083fd7024ce1ac22e9bba90464620e9", size = 748876, upload-time = "2026-03-31T21:57:36.319Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/1b/428a7c64687b3b2e9cd293186695affc0e1e54a445d0361743b231f11066/aiohttp-3.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15c933ad7920b7d9a20de151efcd05a6e38302cbf0e10c9b2acb9a42210a2416", size = 499557, upload-time = "2026-03-31T21:57:38.236Z" },
+    { url = "https://files.pythonhosted.org/packages/29/47/7be41556bfbb6917069d6a6634bb7dd5e163ba445b783a90d40f5ac7e3a7/aiohttp-3.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab2899f9fa2f9f741896ebb6fa07c4c883bfa5c7f2ddd8cf2aafa86fa981b2d2", size = 500258, upload-time = "2026-03-31T21:57:39.923Z" },
+    { url = "https://files.pythonhosted.org/packages/67/84/c9ecc5828cb0b3695856c07c0a6817a99d51e2473400f705275a2b3d9239/aiohttp-3.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a60eaa2d440cd4707696b52e40ed3e2b0f73f65be07fd0ef23b6b539c9c0b0b4", size = 1749199, upload-time = "2026-03-31T21:57:41.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/d3/3c6d610e66b495657622edb6ae7c7fd31b2e9086b4ec50b47897ad6042a9/aiohttp-3.13.5-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:55b3bdd3292283295774ab585160c4004f4f2f203946997f49aac032c84649e9", size = 1721013, upload-time = "2026-03-31T21:57:43.904Z" },
+    { url = "https://files.pythonhosted.org/packages/49/a0/24409c12217456df0bae7babe3b014e460b0b38a8e60753d6cb339f6556d/aiohttp-3.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2b2355dc094e5f7d45a7bb262fe7207aa0460b37a0d87027dcf21b5d890e7d5", size = 1781501, upload-time = "2026-03-31T21:57:46.285Z" },
+    { url = "https://files.pythonhosted.org/packages/98/9d/b65ec649adc5bccc008b0957a9a9c691070aeac4e41cea18559fef49958b/aiohttp-3.13.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b38765950832f7d728297689ad78f5f2cf79ff82487131c4d26fe6ceecdc5f8e", size = 1878981, upload-time = "2026-03-31T21:57:48.734Z" },
+    { url = "https://files.pythonhosted.org/packages/57/d8/8d44036d7eb7b6a8ec4c5494ea0c8c8b94fbc0ed3991c1a7adf230df03bf/aiohttp-3.13.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b18f31b80d5a33661e08c89e202edabf1986e9b49c42b4504371daeaa11b47c1", size = 1767934, upload-time = "2026-03-31T21:57:51.171Z" },
+    { url = "https://files.pythonhosted.org/packages/31/04/d3f8211f273356f158e3464e9e45484d3fb8c4ce5eb2f6fe9405c3273983/aiohttp-3.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:33add2463dde55c4f2d9635c6ab33ce154e5ecf322bd26d09af95c5f81cfa286", size = 1566671, upload-time = "2026-03-31T21:57:53.326Z" },
+    { url = "https://files.pythonhosted.org/packages/41/db/073e4ebe00b78e2dfcacff734291651729a62953b48933d765dc513bf798/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:327cc432fdf1356fb4fbc6fe833ad4e9f6aacb71a8acaa5f1855e4b25910e4a9", size = 1705219, upload-time = "2026-03-31T21:57:55.385Z" },
+    { url = "https://files.pythonhosted.org/packages/48/45/7dfba71a2f9fd97b15c95c06819de7eb38113d2cdb6319669195a7d64270/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:7c35b0bf0b48a70b4cb4fc5d7bed9b932532728e124874355de1a0af8ec4bc88", size = 1743049, upload-time = "2026-03-31T21:57:57.341Z" },
+    { url = "https://files.pythonhosted.org/packages/18/71/901db0061e0f717d226386a7f471bb59b19566f2cae5f0d93874b017271f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:df23d57718f24badef8656c49743e11a89fd6f5358fa8a7b96e728fda2abf7d3", size = 1749557, upload-time = "2026-03-31T21:57:59.626Z" },
+    { url = "https://files.pythonhosted.org/packages/08/d5/41eebd16066e59cd43728fe74bce953d7402f2b4ddfdfef2c0e9f17ca274/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:02e048037a6501a5ec1f6fc9736135aec6eb8a004ce48838cb951c515f32c80b", size = 1558931, upload-time = "2026-03-31T21:58:01.972Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e6/4a799798bf05740e66c3a1161079bda7a3dd8e22ca392481d7a7f9af82a6/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31cebae8b26f8a615d2b546fee45d5ffb76852ae6450e2a03f42c9102260d6fe", size = 1774125, upload-time = "2026-03-31T21:58:04.007Z" },
+    { url = "https://files.pythonhosted.org/packages/84/63/7749337c90f92bc2cb18f9560d67aa6258c7060d1397d21529b8004fcf6f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:888e78eb5ca55a615d285c3c09a7a91b42e9dd6fc699b166ebd5dee87c9ccf14", size = 1732427, upload-time = "2026-03-31T21:58:06.337Z" },
+    { url = "https://files.pythonhosted.org/packages/98/de/cf2f44ff98d307e72fb97d5f5bbae3bfcb442f0ea9790c0bf5c5c2331404/aiohttp-3.13.5-cp312-cp312-win32.whl", hash = "sha256:8bd3ec6376e68a41f9f95f5ed170e2fcf22d4eb27a1f8cb361d0508f6e0557f3", size = 433534, upload-time = "2026-03-31T21:58:08.712Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ca/eadf6f9c8fa5e31d40993e3db153fb5ed0b11008ad5d9de98a95045bed84/aiohttp-3.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:110e448e02c729bcebb18c60b9214a87ba33bac4a9fa5e9a5f139938b56c6cb1", size = 460446, upload-time = "2026-03-31T21:58:10.945Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "antlr4-python3-runtime"
+version = "4.9.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", hash = "sha256:f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b", size = 117034, upload-time = "2021-11-06T17:52:23.524Z" }
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "catalogue"
+version = "2.0.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/38/b4/244d58127e1cdf04cf2dc7d9566f0d24ef01d5ce21811bab088ecc62b5ea/catalogue-2.0.10.tar.gz", hash = "sha256:4f56daa940913d3f09d589c191c74e5a6d51762b3a9e37dd53b7437afd6cda15", size = 19561, upload-time = "2023-09-25T06:29:24.962Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/96/d32b941a501ab566a16358d68b6eb4e4acc373fab3c3c4d7d9e649f7b4bb/catalogue-2.0.10-py3-none-any.whl", hash = "sha256:58c2de0020aa90f4a2da7dfad161bf7b3b054c86a5f09fcedc0b2b740c109a9f", size = 17325, upload-time = "2023-09-25T06:29:23.337Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.5.20"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/ce/ee2ecad540810a79593028e88299baeae54d346cc7a0d94b6199988b89b1/certifi-2026.5.20.tar.gz", hash = "sha256:69dea482ab64caa7b9f6aba1c6bf48bb6a5448d1c0f1b17ab42ad8c763a5344d", size = 135422, upload-time = "2026-05-20T11:46:50.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/8c/57e832b7af6d7c5abe66eb3fbe3a3a32f4d11ea23a1aa7131371035be991/certifi-2026.5.20-py3-none-any.whl", hash = "sha256:3c52e209ba0a4ad7aebe60436a4ab349c39e1e602e8c134221e546902ad25897", size = 134134, upload-time = "2026-05-20T11:46:48.578Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" },
+    { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" },
+    { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" },
+    { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" },
+    { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9b/98/518d8e5081007684232226f475082b30087d0f585e8457db087298259f49/click-8.4.1.tar.gz", hash = "sha256:918b5633eddf6b41c32d4f454bf0de810065c74e3f7dbf8ee5452f8be88d3e96", size = 353007, upload-time = "2026-05-22T04:08:37.769Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/0d/67e5b4109ea4a837e80daa87c2c696711955e40449a97e8926672534def2/click-8.4.1-py3-none-any.whl", hash = "sha256:482be17c6991b8c19c5429a1e995d9b0efdbb63172824c41f99965dc0ade8ec2", size = 116639, upload-time = "2026-05-22T04:08:35.26Z" },
+]
+
+[[package]]
+name = "cloudpickle"
+version = "3.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" },
+    { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" },
+    { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" },
+    { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" },
+    { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" },
+    { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" },
+    { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" },
+]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" },
+]
+
+[[package]]
+name = "datasets"
+version = "4.8.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "dill" },
+    { name = "filelock" },
+    { name = "fsspec", extra = ["http"] },
+    { name = "httpx" },
+    { name = "huggingface-hub" },
+    { name = "multiprocess" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pandas" },
+    { name = "pyarrow" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "tqdm" },
+    { name = "xxhash" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/34/14cd8e76f907f7d4dca2334cfeec9f81d30fd15c25a015f99aaea694eaed/datasets-4.8.5.tar.gz", hash = "sha256:0f0c1c3d56ffff2c93b2f4c63c95bac94f3d7e8621aea2a2a576275233bba772", size = 605649, upload-time = "2026-04-27T15:43:57.384Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/65/99/00f3196036501b53032c4b1ab8337a0b978dee832ed276dae3815df4e8b5/datasets-4.8.5-py3-none-any.whl", hash = "sha256:5079900781719c0e063a8efdd2cd95a31ad0c63209178669cd23cf1b926149ff", size = 528973, upload-time = "2026-04-27T15:43:53.702Z" },
+]
+
+[[package]]
+name = "dill"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/81/e1/56027a71e31b02ddc53c7d65b01e68edf64dea2932122fe7746a516f75d5/dill-0.4.1.tar.gz", hash = "sha256:423092df4182177d4d8ba8290c8a5b640c66ab35ec7da59ccfa00f6fa3eea5fa", size = 187315, upload-time = "2026-01-19T02:36:56.85Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/77/dc8c558f7593132cf8fefec57c4f60c83b16941c574ac5f619abb3ae7933/dill-0.4.1-py3-none-any.whl", hash = "sha256:1e1ce33e978ae97fcfcff5638477032b801c46c7c65cf717f95fbc2248f79a9d", size = 120019, upload-time = "2026-01-19T02:36:55.663Z" },
+]
+
+[[package]]
+name = "etils"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/ce/6e067242fde898841922ac6fc82b0bb2fe35c38e995880bdffdfbe30182a/etils-1.14.0.tar.gz", hash = "sha256:8136e7f4c4173cd0af0ca5481c4475152f0b8686192951eefa60ee8711e1ede4", size = 108127, upload-time = "2026-03-04T17:41:36.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/3d/589663aeeacd59bb2f3e8596bfd3e81cf0fb18d70bb433199041f469771b/etils-1.14.0-py3-none-any.whl", hash = "sha256:b5df7341f54dbe1405a4450b2741207b4a8c279780402b45f87202b94dfc52b4", size = 172934, upload-time = "2026-03-04T17:41:35.01Z" },
+]
+
+[package.optional-dependencies]
+epath = [
+    { name = "fsspec" },
+    { name = "typing-extensions" },
+    { name = "zipp" },
+]
+epy = [
+    { name = "typing-extensions" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.29.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", hash = "sha256:69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90", size = 57571, upload-time = "2026-04-19T15:39:10.068Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", hash = "sha256:96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258", size = 39812, upload-time = "2026-04-19T15:39:08.752Z" },
+]
+
+[[package]]
+name = "flax"
+version = "0.12.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jax" },
+    { name = "msgpack" },
+    { name = "numpy" },
+    { name = "optax" },
+    { name = "orbax-checkpoint" },
+    { name = "pyyaml" },
+    { name = "rich" },
+    { name = "tensorstore" },
+    { name = "treescope" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/93/19/4a8e128e2296eede00dc7a8586d374ef0b2770146a5cda1f50aa86f001ee/flax-0.12.7.tar.gz", hash = "sha256:abfd6acb17d6b93d1d7d7dfae7d3856222b92b35d35ab2487b77639c31dc673a", size = 5476434, upload-time = "2026-04-22T06:07:12.017Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/65/4bd2abfd4cb6e917b2626de5cbfc034dfc94b74dd95b8272d93f2ad66bed/flax-0.12.7-py3-none-any.whl", hash = "sha256:79d590793fa3a282ac36b4464f2ea9d1e69fe1d026c4618451b01731e8086e32", size = 525130, upload-time = "2026-04-22T06:07:10.254Z" },
+]
+
+[[package]]
+name = "fonttools"
+version = "4.63.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/84/69/c97f2c18e0db87d2c7b15da1974dace76ae938f1cfa22e2727a648b7ed43/fonttools-4.63.0.tar.gz", hash = "sha256:caeb583deeb5168e694b65cda8b4ee62abedfa66cf88488734466f2366b9c4e0", size = 3597189, upload-time = "2026-05-14T12:04:30.958Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/08/ef/b3c6b9b5be2f82416d73fe2ed2e96e2793cd80e7510bd6a17ca79cdd88ec/fonttools-4.63.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:37dd23e621e3b0aef1baa70a303b80aaf38449632cfc8fd2a55fb285bbccfc02", size = 2881131, upload-time = "2026-05-14T12:03:13.386Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a0/c815bea63117fa63e4e1c01f8a1110d2112fa003f838e6467094ec2432ce/fonttools-4.63.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a9faff9e0c1f76f9fd55899d2ce785832efebab37eb8ae13995853aef178bef0", size = 2426704, upload-time = "2026-05-14T12:03:15.801Z" },
+    { url = "https://files.pythonhosted.org/packages/44/04/0b91d8e916e92ad1fac9e4624760baf0fd5ff2ead614c2f68fb21373f03f/fonttools-4.63.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef3048ef05dbb552b89817713d9cac912e00d0fde4a3105c00d29e52e10c89af", size = 5044298, upload-time = "2026-05-14T12:03:18.085Z" },
+    { url = "https://files.pythonhosted.org/packages/77/c7/2342da9830e3e9d4870305ca5d2091d2a83284f2953079b7bdd3b5e029d8/fonttools-4.63.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58dc6bb86a78d782f00f9190ca02c119cf5bbe2807536e361e18d42019f877d8", size = 4999800, upload-time = "2026-05-14T12:03:20.161Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/6d/67fe16c48d7ce050979b33f47e0d28a318f02da030602e944c34f7a16ef3/fonttools-4.63.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ee08ebfa58f6e1aeff5697ab9582105bb620008c1caafb681e4c557e7483027b", size = 4982666, upload-time = "2026-05-14T12:03:22.87Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/00/3bbab338c07c71fa56269953845e92c951a61457bbbb0f1022551ea266d9/fonttools-4.63.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:27fdc65af8da6f88b9c6121c47a464cbe359fcfff7ff6fc2d37a1f395d755b78", size = 5133598, upload-time = "2026-05-14T12:03:25.168Z" },
+    { url = "https://files.pythonhosted.org/packages/62/f2/aa27c7f98db5b064883dadcc5283947e81e034de42e22a33675878d98b54/fonttools-4.63.0-cp312-cp312-win32.whl", hash = "sha256:af2fd1664d00a397d75f806985ddb36282091c2131a73a6485c23b4a34722263", size = 2292575, upload-time = "2026-05-14T12:03:27.496Z" },
+    { url = "https://files.pythonhosted.org/packages/87/36/cccb9bc2a6ab63d1b2980374f0dca72ce95ae267c9b4cfe77455bb70d0d4/fonttools-4.63.0-cp312-cp312-win_amd64.whl", hash = "sha256:59ac449f8cca9b4ffa08d2e7bbadad87ce710d69d1eda5c3c1ce579baa987272", size = 2343211, upload-time = "2026-05-14T12:03:30.057Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "fsspec"
+version = "2026.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/51/7c/f60c259dcbf4f0c47cc4ddb8f7720d2dcdc8888c8e5ad84c73ea4531cc5b/fsspec-2026.2.0.tar.gz", hash = "sha256:6544e34b16869f5aacd5b90bdf1a71acb37792ea3ddf6125ee69a22a53fb8bff", size = 313441, upload-time = "2026-02-05T21:50:53.743Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ab/fb21f4c939bb440104cc2b396d3be1d9b7a9fd3c6c2a53d98c45b3d7c954/fsspec-2026.2.0-py3-none-any.whl", hash = "sha256:98de475b5cb3bd66bedd5c4679e87b4fdfe1a3bf4d707b151b3c07e58c9a2437", size = 202505, upload-time = "2026-02-05T21:50:51.819Z" },
+]
+
+[package.optional-dependencies]
+http = [
+    { name = "aiohttp" },
+]
+
+[[package]]
+name = "gitdb"
+version = "4.0.12"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "smmap" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794, upload-time = "2025-01-02T07:20:43.624Z" },
+]
+
+[[package]]
+name = "gitpython"
+version = "3.1.50"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "gitdb" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/33/f6/354ae6491228b5eb40e10d89c4d13c651fe1cf7556e35ebdded50cff57ce/gitpython-3.1.50.tar.gz", hash = "sha256:80da2d12504d52e1f998772dc5baf6e553f8d2fcfe1fcc226c9d9a2ee3372dcc", size = 219798, upload-time = "2026-05-06T04:01:26.571Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/7a/1c6e3562dfd8950adbb11ffbc65d21e7c89d01a6e4f137fa981056de25c5/gitpython-3.1.50-py3-none-any.whl", hash = "sha256:d352abe2908d07355014abdd21ddf798c2a961469239afec4962e9da884858f9", size = 212507, upload-time = "2026-05-06T04:01:23.799Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "hf-xet"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/d8/5c06fc76461418326a7decf8367480c35be11a41fd938633929c60a9ec6b/hf_xet-1.5.0.tar.gz", hash = "sha256:e0fb0a34d9f406eed88233e829a67ec016bec5af19e480eac65a233ea289a948", size = 837196, upload-time = "2026-05-06T06:18:15.583Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/fb/69ff198a82cae7eb1a69fb84d93b3a3e4816564d76817fe541ddc96874eb/hf_xet-1.5.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:dad0dc84e941b8ba3c860659fe1fdc35c049d47cce293f003287757e971a8f56", size = 4030814, upload-time = "2026-05-06T06:17:57.933Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/ff/edcc2b40162bef3ff78e14ab637e5f3b89243d6aee72f5949d3bb6a5af83/hf_xet-1.5.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:fd6e5a9b0fdac4ed03ed45ef79254a655b1aaab514a02202617fbf643f5fdf7a", size = 3798444, upload-time = "2026-05-06T06:17:55.79Z" },
+    { url = "https://files.pythonhosted.org/packages/49/4d/103f76b04310e5e57656696cc184690d20c466af0bca3ca88f8c8ea5d4f3/hf_xet-1.5.0-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3531b1823a0e6d77d80f9ed15ca0e00f0d115094f8ac033d5cae88f4564cc949", size = 4465986, upload-time = "2026-05-06T06:17:44.886Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a2/546f47f464737b3edbab6f8ddb57f2599b93d2cbb66f06abb475ccb48651/hf_xet-1.5.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:9a0ee58cd18d5ea799f7ed11290bbccbe56bdd8b1d97ca74b9cc49a3945d7a3b", size = 4259865, upload-time = "2026-05-06T06:17:42.639Z" },
+    { url = "https://files.pythonhosted.org/packages/95/7f/1be593c1f28613be2e196473481cd81bfc5910795e30a34e8f744f6cac4f/hf_xet-1.5.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1e60df5a42e9bed8628b6416af2cba4cba57ae9f02de226a06b020d98e1aab18", size = 4459835, upload-time = "2026-05-06T06:18:08.026Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b2/703569fc881f3284487e68cda7b42179978480da3c438042a6bbbb4a671c/hf_xet-1.5.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:4b35549ce62601b84da4ff9b24d970032ace3d4430f52d91bcbb26c901d6c690", size = 4672414, upload-time = "2026-05-06T06:18:09.864Z" },
+    { url = "https://files.pythonhosted.org/packages/af/37/1b6def445c567286b50aa3b33828158e135b1be44938dde59f11382a500c/hf_xet-1.5.0-cp37-abi3-win_amd64.whl", hash = "sha256:2806c7c17b4d23f8d88f7c4814f838c3b6150773fe339c20af23e1cfaf2797e4", size = 3977238, upload-time = "2026-05-06T06:18:23.621Z" },
+    { url = "https://files.pythonhosted.org/packages/62/94/3b66b148778ee100dcfd69c2ca22b57b41b44d3063ceec934f209e9184ce/hf_xet-1.5.0-cp37-abi3-win_arm64.whl", hash = "sha256:b6c9df403040248c76d808d3e047d64db2d923bae593eb244c41e425cf6cd7be", size = 3806916, upload-time = "2026-05-06T06:18:21.7Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "huggingface-hub"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "filelock" },
+    { name = "fsspec" },
+    { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" },
+    { name = "httpx" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "tqdm" },
+    { name = "typer" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bd/65/9826515abb600b5722bcf53f8b4a2fb58340b1f8bfcaee19f83561c13a44/huggingface_hub-1.17.0.tar.gz", hash = "sha256:fad842b6763ef70ebc3919665b1b9273645203185400a7d6c5eddc2323cc3435", size = 797082, upload-time = "2026-05-28T15:12:13.347Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/28/d7cef5e477b855c25d415b8f57e5bc7347c7a90cad3acf1725d0c92ca294/huggingface_hub-1.17.0-py3-none-any.whl", hash = "sha256:3b8156d23118e87f6a587648bfbc04f04a12a757ccb4ed298b35c4ae638bf24c", size = 671546, upload-time = "2026-05-28T15:12:11.441Z" },
+]
+
+[[package]]
+name = "humanize"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/66/a3921783d54be8a6870ac4ccffcd15c4dc0dd7fcce51c6d63b8c63935276/humanize-4.15.0.tar.gz", hash = "sha256:1dd098483eb1c7ee8e32eb2e99ad1910baefa4b75c3aff3a82f4d78688993b10", size = 83599, upload-time = "2025-12-20T20:16:13.19Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/7b/bca5613a0c3b542420cf92bd5e5fb8ebd5435ce1011a091f66bb7693285e/humanize-4.15.0-py3-none-any.whl", hash = "sha256:b1186eb9f5a9749cd9cb8565aee77919dd7c8d076161cf44d70e59e3301e1769", size = 132203, upload-time = "2025-12-20T20:16:11.67Z" },
+]
+
+[[package]]
+name = "hydra-core"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "antlr4-python3-runtime" },
+    { name = "omegaconf" },
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/8e/07e42bc434a847154083b315779b0a81d567154504624e181caf2c71cd98/hydra-core-1.3.2.tar.gz", hash = "sha256:8a878ed67216997c3e9d88a8e72e7b4767e81af37afb4ea3334b269a4390a824", size = 3263494, upload-time = "2023-02-23T18:33:43.03Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/50/e0edd38dcd63fb26a8547f13d28f7a008bc4a3fd4eb4ff030673f22ad41a/hydra_core-1.3.2-py3-none-any.whl", hash = "sha256:fa0238a9e31df3373b35b0bfb672c34cc92718d21f81311d8996a16de1141d8b", size = 154547, upload-time = "2023-02-23T18:33:40.801Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.17"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", hash = "sha256:5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f", size = 196048, upload-time = "2026-05-28T14:32:38.55Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", hash = "sha256:466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c", size = 65316, upload-time = "2026-05-28T14:32:37.035Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jax"
+version = "0.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jaxlib" },
+    { name = "ml-dtypes" },
+    { name = "numpy" },
+    { name = "opt-einsum" },
+    { name = "scipy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/24/49/b082387119c4a6bc7596296bbdc6bce034628cdd2845ebb27304cbca3624/jax-0.10.1.tar.gz", hash = "sha256:11672410faf8752429eb9a131de203dc488a2a3a012d509baa2b39878008810d", size = 2718178, upload-time = "2026-05-20T14:54:09.441Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/6e/5087e0347188f6970aba1ffbd0018754d23c3f3461e9f21785f2f27a02c2/jax-0.10.1-py3-none-any.whl", hash = "sha256:47f3192c76e9e3358de1b106a8af5e943fccb10510903f25d96ea53652729134", size = 3150973, upload-time = "2026-05-20T14:51:30.066Z" },
+]
+
+[package.optional-dependencies]
+cuda12 = [
+    { name = "jax-cuda12-plugin", extra = ["with-cuda"], marker = "sys_platform == 'linux'" },
+    { name = "jaxlib", marker = "sys_platform == 'linux'" },
+]
+
+[[package]]
+name = "jax-cuda12-pjrt"
+version = "0.10.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/e0/2ad8ab2d3c299ec1befccf88e6618f4d8d8b05f430a3e52f11d2f66609e9/jax_cuda12_pjrt-0.10.1-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:07046311b1657ec77cb4b0719a3e3a829194e2e1dd530bbe543182f6a4260ca6", size = 159056392, upload-time = "2026-05-20T14:51:33.827Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a1/47c08a81760cae84c4a4aa720f3fc1ce3bac6f7aafa5ab82c302d7946f07/jax_cuda12_pjrt-0.10.1-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:4c50a469f1b7c2fbba278d5b6932fe33de41f833b333cae28151422ec456857d", size = 164801423, upload-time = "2026-05-20T14:51:39.431Z" },
+]
+
+[[package]]
+name = "jax-cuda12-plugin"
+version = "0.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jax-cuda12-pjrt", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/f3/131a1bf5e666821f97e7e515063bd408259ce025682c2c0748960aceb669/jax_cuda12_plugin-0.10.1-cp312-cp312-manylinux_2_27_aarch64.whl", hash = "sha256:34d62485ee26d8d69b336291808a8f88656797607e2df01082fc0824292e11d9", size = 7862325, upload-time = "2026-05-20T14:51:47.033Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/3f/cabd3c791ff5042df157609e00e96440ccaba69f72bccd8e3470d85fdd48/jax_cuda12_plugin-0.10.1-cp312-cp312-manylinux_2_27_x86_64.whl", hash = "sha256:83e7740f6536a3dc82cdf1d510c944bcbdcfd1b36abf875adc4013fea3bf934e", size = 7910790, upload-time = "2026-05-20T14:51:49.731Z" },
+]
+
+[package.optional-dependencies]
+with-cuda = [
+    { name = "nvidia-cublas-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cuda-cupti-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cuda-nvcc-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cuda-nvrtc-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cuda-runtime-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cudnn-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cufft-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cusolver-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cusparse-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nccl-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nvshmem-cu12", marker = "sys_platform == 'linux'" },
+]
+
+[[package]]
+name = "jaxlib"
+version = "0.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ml-dtypes" },
+    { name = "numpy" },
+    { name = "scipy" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/53/b4/fdb6e989b142d8a8d2093f342cbc5323fe0d4a7217fd899c8ddf9e108a5a/jaxlib-0.10.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7a4399c7429c87ee6f7ab1e5712c5548ecfabde974ee9f4a12957fea4e35efb8", size = 60816137, upload-time = "2026-05-20T14:52:53.028Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/29/0b4eaaca005708751ff301903a2ca760dcc34175dadb7536498c57a7de85/jaxlib-0.10.1-cp312-cp312-manylinux_2_27_aarch64.whl", hash = "sha256:12126603ba472300c62480f86d20972d563143041039d9dea349ad510aa6123c", size = 80294034, upload-time = "2026-05-20T14:52:56.941Z" },
+    { url = "https://files.pythonhosted.org/packages/38/69/2912ab63036e21c72748019e1d8e09e8a1fc3368b3e83fc27898a1858575/jaxlib-0.10.1-cp312-cp312-manylinux_2_27_x86_64.whl", hash = "sha256:f3cdf5b7f48470ab5455ab79aab746419694ccb6b52651cc2ce5fb27def03588", size = 85828774, upload-time = "2026-05-20T14:53:01.749Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/8f/993ea419eca6f34fe12613e22a03b93f40e5b1e8e0df18d4060e1313a1fc/jaxlib-0.10.1-cp312-cp312-win_amd64.whl", hash = "sha256:0acf3f8e7dca9074c0327f0f61502845792ca9f82fab23b841b00daa78e85488", size = 64830187, upload-time = "2026-05-20T14:53:05.932Z" },
+]
+
+[[package]]
+name = "kiwisolver"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" },
+    { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" },
+    { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.10.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "contourpy" },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "kiwisolver" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/35/c6/5581e26c72233ebb2a2a6fed2d24fb7c66b4700120b813f51b0555acf0b6/matplotlib-3.10.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0c3c28d9fbcc1fe7a03be236d73430cf6409c41fb2383a7ac52fe932b072cb1", size = 8319908, upload-time = "2026-04-24T00:12:21.323Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/18/4880dd762e40cd360c1bf06e890c5a97b997e91cb324602b1a19950ad5ce/matplotlib-3.10.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:41cb28c2bd769aa3e98322c6ab09854cbcc52ab69d2759d681bba3e327b2b320", size = 8216016, upload-time = "2026-04-24T00:12:23.4Z" },
+    { url = "https://files.pythonhosted.org/packages/32/91/d024616abdba99e83120e07a20658976f6a343646710760c4a51df126029/matplotlib-3.10.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ae20801130378b82d647ff5047c07316295b68dc054ca6b3c13519d0ea624285", size = 8789336, upload-time = "2026-04-24T00:12:26.096Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/04/030a2f61ef2158f5e4c259487a92ac877732499fb33d871585d89e03c42d/matplotlib-3.10.9-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c63ebcd8b4b169eb2f5c200552ae6b8be8999a005b6b507ed76fb8d7d674fe2", size = 9604602, upload-time = "2026-04-24T00:12:29.052Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/c2/541e4d09d87bb6b5830fc28b4c887a9a8cf4e1c6cee698a8c05552ae2003/matplotlib-3.10.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d75d11c949914165976c621b2324f9ef162af7ebf4b057ddf95dd1dba7e5edcf", size = 9670966, upload-time = "2026-04-24T00:12:32.131Z" },
+    { url = "https://files.pythonhosted.org/packages/04/a1/4571fc46e7702de8d0c2dc54ad1b2f8e29328dea3ee90831181f7353d93c/matplotlib-3.10.9-cp312-cp312-win_amd64.whl", hash = "sha256:d091f9d758b34aaaaa6331d13574bf01891d903b3dec59bfff458ef7551de5d6", size = 8217462, upload-time = "2026-04-24T00:12:35.226Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/d0/2269edb12aa30c13c8bcc9382892e39943ce1d28aab4ec296e0381798e81/matplotlib-3.10.9-cp312-cp312-win_arm64.whl", hash = "sha256:10cc5ce06d10231c36f40e875f3c7e8050362a4ee8f0ee5d29a6b3277d57bb42", size = 8136688, upload-time = "2026-04-24T00:12:37.442Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "ml-datasets"
+version = "0.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "catalogue" },
+    { name = "cloudpickle" },
+    { name = "numpy" },
+    { name = "srsly" },
+    { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/35/02/3fcb299943fbd0ee9a413bc8859543cb26f748eff4fa1c5cb94f38b1aa2a/ml_datasets-0.2.1.tar.gz", hash = "sha256:1613d4c1bcab27f35aa0274f2808e330b5da7ea1efc5f364fe2b0025a84eb160", size = 16769, upload-time = "2026-03-23T10:12:44.081Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/9b/de53b40cb23fd251201916b3fd8d2d8d7b48bdfc61106efcc287b303da16/ml_datasets-0.2.1-py3-none-any.whl", hash = "sha256:867309f08a97bd97adad0edc9872eb01bdde0fd974d4567df06a8b08b1b4d4aa", size = 20102, upload-time = "2026-03-23T10:12:42.658Z" },
+]
+
+[[package]]
+name = "ml-dtypes"
+version = "0.5.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/4a/c27b42ed9b1c7d13d9ba8b6905dece787d6259152f2309338aed29b2447b/ml_dtypes-0.5.4.tar.gz", hash = "sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453", size = 692314, upload-time = "2025-11-17T22:32:31.031Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/b8/3c70881695e056f8a32f8b941126cf78775d9a4d7feba8abcb52cb7b04f2/ml_dtypes-0.5.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac", size = 676927, upload-time = "2025-11-17T22:31:48.182Z" },
+    { url = "https://files.pythonhosted.org/packages/54/0f/428ef6881782e5ebb7eca459689448c0394fa0a80bea3aa9262cba5445ea/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900", size = 5028464, upload-time = "2025-11-17T22:31:50.135Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/cb/28ce52eb94390dda42599c98ea0204d74799e4d8047a0eb559b6fd648056/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff", size = 5009002, upload-time = "2025-11-17T22:31:52.001Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f0/0cfadd537c5470378b1b32bd859cf2824972174b51b873c9d95cfd7475a5/ml_dtypes-0.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7", size = 212222, upload-time = "2025-11-17T22:31:53.742Z" },
+    { url = "https://files.pythonhosted.org/packages/16/2e/9acc86985bfad8f2c2d30291b27cd2bb4c74cea08695bd540906ed744249/ml_dtypes-0.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460", size = 160793, upload-time = "2025-11-17T22:31:55.358Z" },
+]
+
+[[package]]
+name = "msgpack"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" },
+    { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" },
+    { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "multiprocess"
+version = "0.70.19"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "dill" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a2/f2/e783ac7f2aeeed14e9e12801f22529cc7e6b7ab80928d6dcce4e9f00922d/multiprocess-0.70.19.tar.gz", hash = "sha256:952021e0e6c55a4a9fe4cd787895b86e239a40e76802a789d6305398d3975897", size = 2079989, upload-time = "2026-01-19T06:47:39.744Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e3/45/8004d1e6b9185c1a444d6b55ac5682acf9d98035e54386d967366035a03a/multiprocess-0.70.19-py310-none-any.whl", hash = "sha256:97404393419dcb2a8385910864eedf47a3cadf82c66345b44f036420eb0b5d87", size = 134948, upload-time = "2026-01-19T06:47:32.325Z" },
+    { url = "https://files.pythonhosted.org/packages/86/c2/dec9722dc3474c164a0b6bcd9a7ed7da542c98af8cabce05374abab35edd/multiprocess-0.70.19-py311-none-any.whl", hash = "sha256:928851ae7973aea4ce0eaf330bbdafb2e01398a91518d5c8818802845564f45c", size = 144457, upload-time = "2026-01-19T06:47:33.711Z" },
+    { url = "https://files.pythonhosted.org/packages/71/70/38998b950a97ea279e6bd657575d22d1a2047256caf707d9a10fbce4f065/multiprocess-0.70.19-py312-none-any.whl", hash = "sha256:3a56c0e85dd5025161bac5ce138dcac1e49174c7d8e74596537e729fd5c53c28", size = 150281, upload-time = "2026-01-19T06:47:35.037Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/82/69e539c4c2027f1e1697e09aaa2449243085a0edf81ae2c6341e84d769b6/multiprocess-0.70.19-py39-none-any.whl", hash = "sha256:0d4b4397ed669d371c81dcd1ef33fd384a44d6c3de1bd0ca7ac06d837720d3c5", size = 133477, upload-time = "2026-01-19T06:47:38.619Z" },
+]
+
+[[package]]
+name = "nest-asyncio"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" },
+    { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" },
+    { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" },
+]
+
+[[package]]
+name = "nvidia-cublas-cu12"
+version = "12.9.2.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cuda-nvrtc-cu12", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/a2/c96163a0fff1839c0c9548bbdeae7b853b867009e33b9b9264adc238b1cf/nvidia_cublas_cu12-12.9.2.10-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:5572131a59c3eebeeb1c4c8144f772d49372c20124916e072a0e3fc30df421d5", size = 575012079, upload-time = "2026-04-08T18:51:47.303Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c0/0a517bfe63ccd3b92eb254d264e28fca3c7cab75d07daea315250fb1bf73/nvidia_cublas_cu12-12.9.2.10-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:e4f53a8ca8c5d6e8c492d0d0a3d565ecb59a751b19cfdaa4f6da0ab2104c1702", size = 581240110, upload-time = "2026-04-08T18:52:31.532Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-cccl-cu12"
+version = "12.9.27"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/7e/82e49956b046bdc506c789235c587d9b3ef58b8bc1782258c1e247229647/nvidia_cuda_cccl_cu12-12.9.27-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d7898b38aa68beaa234d48f0868273702342a196d6e2e9d0ef058dca2390ebea", size = 3152245, upload-time = "2025-05-01T19:32:04.802Z" },
+    { url = "https://files.pythonhosted.org/packages/18/2a/d4cd8506d2044e082f8cd921be57392e6a9b5ccd3ffdf050362430a3d5d5/nvidia_cuda_cccl_cu12-12.9.27-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:37869e17ce2e1ecec6eddf1927cca0f8c34e64fd848d40453df559091e2d7117", size = 3152243, upload-time = "2025-05-01T19:32:13.955Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-cupti-cu12"
+version = "12.9.79"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/78/351b5c8cdbd9a6b4fb0d6ee73fb176dcdc1b6b6ad47c2ffff5ae8ca4a1f7/nvidia_cuda_cupti_cu12-12.9.79-py3-none-manylinux_2_25_aarch64.whl", hash = "sha256:791853b030602c6a11d08b5578edfb957cadea06e9d3b26adbf8d036135a4afe", size = 10077166, upload-time = "2025-06-05T20:01:01.385Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/2e/b84e32197e33f39907b455b83395a017e697c07a449a2b15fd07fc1c9981/nvidia_cuda_cupti_cu12-12.9.79-py3-none-manylinux_2_25_x86_64.whl", hash = "sha256:096bcf334f13e1984ba36685ad4c1d6347db214de03dbb6eebb237b41d9d934f", size = 10814997, upload-time = "2025-06-05T20:01:10.168Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvcc-cu12"
+version = "12.9.86"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/48/b54a06168a2190572a312bfe4ce443687773eb61367ced31e064953dd2f7/nvidia_cuda_nvcc_cu12-12.9.86-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:5d6a0d32fdc7ea39917c20065614ae93add6f577d840233237ff08e9a38f58f0", size = 40546229, upload-time = "2025-06-05T20:01:53.357Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/5c/8cc072436787104bbbcbde1f76ab4a0d89e68f7cebc758dd2ad7913a43d0/nvidia_cuda_nvcc_cu12-12.9.86-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:44e1eca4d08926193a558d2434b1bf83d57b4d5743e0c431c0c83d51da1df62b", size = 39411138, upload-time = "2025-06-05T20:01:43.182Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc-cu12"
+version = "12.9.86"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b8/85/e4af82cc9202023862090bfca4ea827d533329e925c758f0cde964cb54b7/nvidia_cuda_nvrtc_cu12-12.9.86-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:210cf05005a447e29214e9ce50851e83fc5f4358df8b453155d5e1918094dcb4", size = 89568129, upload-time = "2025-06-05T20:02:41.973Z" },
+    { url = "https://files.pythonhosted.org/packages/64/eb/c2295044b8f3b3b08860e2f6a912b702fc92568a167259df5dddb78f325e/nvidia_cuda_nvrtc_cu12-12.9.86-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:096d4de6bda726415dfaf3198d4f5c522b8e70139c97feef5cd2ca6d4cd9cead", size = 44528905, upload-time = "2025-06-05T20:02:29.754Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-runtime-cu12"
+version = "12.9.79"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/e0/0279bd94539fda525e0c8538db29b72a5a8495b0c12173113471d28bce78/nvidia_cuda_runtime_cu12-12.9.79-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:83469a846206f2a733db0c42e223589ab62fd2fabac4432d2f8802de4bded0a4", size = 3515012, upload-time = "2025-06-05T20:00:35.519Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/46/a92db19b8309581092a3add7e6fceb4c301a3fd233969856a8cbf042cd3c/nvidia_cuda_runtime_cu12-12.9.79-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:25bba2dfb01d48a9b59ca474a1ac43c6ebf7011f1b0b8cc44f54eb6ac48a96c3", size = 3493179, upload-time = "2025-06-05T20:00:53.735Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-cu12"
+version = "9.24.0.43"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas-cu12", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/f1/cd42563325fa827f54ff30da05686c747652bdbd4cb5654cea54d7d0ad4f/nvidia_cudnn_cu12-9.24.0.43-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:a42996943f0cd78ddfd61c8bf59361672a19b63e0491aa22a53d6fe63a3f854a", size = 856490582, upload-time = "2026-07-02T16:21:30.924Z" },
+    { url = "https://files.pythonhosted.org/packages/10/13/b8887c869cf2471339a24b60d3c28e761facbb534935f572b61423371abb/nvidia_cudnn_cu12-9.24.0.43-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:f424192dd85e7d29f44be18df2dae4c80d32c67a29c0d42f5c283c40cfdf871c", size = 799083985, upload-time = "2026-07-02T16:25:37.467Z" },
+]
+
+[[package]]
+name = "nvidia-cufft-cu12"
+version = "11.4.1.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/2b/76445b0af890da61b501fde30650a1a4bd910607261b209cccb5235d3daa/nvidia_cufft_cu12-11.4.1.4-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1a28c9b12260a1aa7a8fd12f5ebd82d027963d635ba82ff39a1acfa7c4c0fbcf", size = 200822453, upload-time = "2025-06-05T20:05:27.889Z" },
+    { url = "https://files.pythonhosted.org/packages/95/f4/61e6996dd20481ee834f57a8e9dca28b1869366a135e0d42e2aa8493bdd4/nvidia_cufft_cu12-11.4.1.4-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c67884f2a7d276b4b80eb56a79322a95df592ae5e765cf1243693365ccab4e28", size = 200877592, upload-time = "2025-06-05T20:05:45.862Z" },
+]
+
+[[package]]
+name = "nvidia-cusolver-cu12"
+version = "11.7.5.82"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cusparse-cu12", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/99/686ff9bf3a82a531c62b1a5c614476e8dfa24a9d89067aeedf3592ee4538/nvidia_cusolver_cu12-11.7.5.82-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:62efa83e4ace59a4c734d052bb72158e888aa7b770e1a5f601682f16fe5b4fd2", size = 337869834, upload-time = "2025-06-05T20:06:53.125Z" },
+    { url = "https://files.pythonhosted.org/packages/33/40/79b0c64d44d6c166c0964ec1d803d067f4a145cca23e23925fd351d0e642/nvidia_cusolver_cu12-11.7.5.82-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:15da72d1340d29b5b3cf3fd100e3cd53421dde36002eda6ed93811af63c40d88", size = 338117415, upload-time = "2025-06-05T20:07:16.809Z" },
+]
+
+[[package]]
+name = "nvidia-cusparse-cu12"
+version = "12.5.10.65"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink-cu12", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5e/6f/8710fbd17cdd1d0fc3fea7d36d5b65ce1933611c31e1861da330206b253a/nvidia_cusparse_cu12-12.5.10.65-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:221c73e7482dd93eda44e65ce567c031c07e2f93f6fa0ecd3ba876a195023e83", size = 366359408, upload-time = "2025-06-05T20:07:42.501Z" },
+    { url = "https://files.pythonhosted.org/packages/12/46/b0fd4b04f86577921feb97d8e2cf028afe04f614d17fb5013de9282c9216/nvidia_cusparse_cu12-12.5.10.65-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:73060ce019ac064a057267c585bf1fd5a353734151f87472ff02b2c5c9984e78", size = 366465088, upload-time = "2025-06-05T20:08:20.413Z" },
+]
+
+[[package]]
+name = "nvidia-nccl-cu12"
+version = "2.30.7"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/8c/554bb020501d6c04ad8127d83f728137f8f9123f991666efbdcf9095a221/nvidia_nccl_cu12-2.30.7-py3-none-manylinux_2_18_aarch64.whl", hash = "sha256:03ecd776fd1d58fd2c9a0a687dcf8db9ecd0057382dba646fa3d65786d4a9ea1", size = 303277471, upload-time = "2026-06-09T03:24:16.327Z" },
+    { url = "https://files.pythonhosted.org/packages/50/32/e7ffa9c324ae260e5dbb4af2cd557bf7a8d155c8ac7b79a785fe1796fb92/nvidia_nccl_cu12-2.30.7-py3-none-manylinux_2_18_x86_64.whl", hash = "sha256:8ce1b8213f61f2bfac132e6df890af6450b77cbd140c6ce4e98cb0c2d8e678c9", size = 303361239, upload-time = "2026-06-09T03:24:53.816Z" },
+]
+
+[[package]]
+name = "nvidia-nvjitlink-cu12"
+version = "12.9.86"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/0c/c75bbfb967457a0b7670b8ad267bfc4fffdf341c074e0a80db06c24ccfd4/nvidia_nvjitlink_cu12-12.9.86-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:e3f1171dbdc83c5932a45f0f4c99180a70de9bd2718c1ab77d14104f6d7147f9", size = 39748338, upload-time = "2025-06-05T20:10:25.613Z" },
+    { url = "https://files.pythonhosted.org/packages/97/bc/2dcba8e70cf3115b400fef54f213bcd6715a3195eba000f8330f11e40c45/nvidia_nvjitlink_cu12-12.9.86-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:994a05ef08ef4b0b299829cde613a424382aff7efb08a7172c1fa616cc3af2ca", size = 39514880, upload-time = "2025-06-05T20:10:04.89Z" },
+]
+
+[[package]]
+name = "nvidia-nvshmem-cu12"
+version = "3.7.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cuda-cccl-cu12", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/a1/9ca9cc3338217311cee21f7ba795dad4f38b7a279a6da7d3d549258f60b1/nvidia_nvshmem_cu12-3.7.2-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:98495de30994f1401a12cc8158ffacbeada44579f54185d75665381468056faa", size = 229963056, upload-time = "2026-07-17T19:23:44.067Z" },
+    { url = "https://files.pythonhosted.org/packages/63/03/cde130e3ff706784f9efd47204f299b15113ea08203e98a556603dac245d/nvidia_nvshmem_cu12-3.7.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:02b6d3482d90ea8ba214bc400362297f573257763990a98c9846ec5c786a7227", size = 230171132, upload-time = "2026-07-17T19:25:07.092Z" },
+]
+
+[[package]]
+name = "omegaconf"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "antlr4-python3-runtime" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", hash = "sha256:d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7", size = 3298120, upload-time = "2022-12-08T20:59:22.753Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl", hash = "sha256:7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b", size = 79500, upload-time = "2022-12-08T20:59:19.686Z" },
+]
+
+[[package]]
+name = "opt-einsum"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/b9/2ac072041e899a52f20cf9510850ff58295003aa75525e58343591b0cbfb/opt_einsum-3.4.0.tar.gz", hash = "sha256:96ca72f1b886d148241348783498194c577fa30a8faac108586b14f1ba4473ac", size = 63004, upload-time = "2024-09-26T14:33:24.483Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/23/cd/066e86230ae37ed0be70aae89aabf03ca8d9f39c8aea0dec8029455b5540/opt_einsum-3.4.0-py3-none-any.whl", hash = "sha256:69bb92469f86a1565195ece4ac0323943e83477171b91d24c35afe028a90d7cd", size = 71932, upload-time = "2024-09-26T14:33:23.039Z" },
+]
+
+[[package]]
+name = "optax"
+version = "0.2.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "absl-py" },
+    { name = "jax" },
+    { name = "jaxlib" },
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8c/f9/e3d11ae6f298ee941a0690e353a323d158ba5dedc436e75621c310845c5c/optax-0.2.8.tar.gz", hash = "sha256:5b225b35066fc3eebaa4d798f1b4173b4d57d1a480610908981f8343b50af0b0", size = 301193, upload-time = "2026-03-20T23:30:05.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/69/6a93d8600c339d7687a05857c7907bd4dd8cf88691a5ea106d7a50af90a1/optax-0.2.8-py3-none-any.whl", hash = "sha256:e3ca2d36c99daab1800ae9dbc0545034382d6bc780b24d969e1b0df65fa31cb4", size = 402960, upload-time = "2026-03-20T23:30:03.886Z" },
+]
+
+[[package]]
+name = "orbax-checkpoint"
+version = "0.11.40"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "absl-py" },
+    { name = "aiofiles" },
+    { name = "etils", extra = ["epath", "epy"] },
+    { name = "humanize" },
+    { name = "jax" },
+    { name = "msgpack" },
+    { name = "nest-asyncio", marker = "sys_platform == 'win32'" },
+    { name = "numpy" },
+    { name = "prometheus-client" },
+    { name = "protobuf" },
+    { name = "psutil" },
+    { name = "pyyaml" },
+    { name = "simplejson" },
+    { name = "tensorstore" },
+    { name = "typing-extensions" },
+    { name = "uvloop", marker = "sys_platform != 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e2/58/89183fb43fd87a7fcd8af9c5a3f396c6620ac93742a5fa8333cde8f3789d/orbax_checkpoint-0.11.40.tar.gz", hash = "sha256:da7e873cfcef5f792b86936a36935f298bf229a0900b2fec57fccca750056b61", size = 637227, upload-time = "2026-05-19T18:20:17.584Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/60/829ed84939aaa8c7d4693e255b9b9d9a61d14c3426d45ab05218b1f49d3b/orbax_checkpoint-0.11.40-py3-none-any.whl", hash = "sha256:b125a3d56dcb6968862b5a2404d49d06ce6840fd5908fc2a2ef8b680b5ac3bce", size = 1229694, upload-time = "2026-05-19T18:20:14.752Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "python-dateutil" },
+    { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f8/87/4341c6252d1c47b08768c3d25ac487362bf403f0313ddae4a2a26c9b1b4c/pandas-3.0.3.tar.gz", hash = "sha256:696a4a00a2a2a35d4e5deb3fc946641b96c944f02230e4f76137fe35d806c4fc", size = 4651414, upload-time = "2026-05-11T18:54:29.21Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/f1/392f8c5bfc16f66a0d2d41561c01627c228fe7ed2a0d056ef11315042570/pandas-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fed2ff7fd9779120e388e285fc029bd5cf9490cdd2e4166a9ee22c0e49a9ab09", size = 10357846, upload-time = "2026-05-11T18:52:36.143Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3d/b16412745651e855f357e5e66930248688378853a6e2698a214e331fba1f/pandas-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b168fc218fd80a6cbdbdbc1a97ddc7889ed057d7eb45f50d866ceab5f39904c4", size = 9899550, upload-time = "2026-05-11T18:52:38.976Z" },
+    { url = "https://files.pythonhosted.org/packages/31/a8/fa2535168fffcedf67f4f6de28d2dd903a747ca7c8ea6989451aaeb3a92f/pandas-3.0.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0383c72c75cdcca61a9e116e611143902dbfd08bff356829c2f6d1cf40a9ca8c", size = 10412965, upload-time = "2026-05-11T18:52:41.915Z" },
+    { url = "https://files.pythonhosted.org/packages/65/b6/09b01cdbc15224e2850365192d17b7bdebb8bdbd8780ed221fcdf0d9a515/pandas-3.0.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6dc0b3fd2169c9157deed50b4d519553a3655c8c6a96027136d654592be973a9", size = 10894600, upload-time = "2026-05-11T18:52:45.02Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/a4/2eb28f2fccb4ced4a2c79ab2a5dee9ade1ebf44922ebad6fea158c9f95d4/pandas-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7e65d5407dc0b394f509699650e4a2ec01c0514f21850f453fa60f3be79a5dbf", size = 11422824, upload-time = "2026-05-11T18:52:48.058Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/45/830bb57f533a4604b355e07edcb8ea18cf88b5f94e5fca92f27052d7c597/pandas-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f8894dc474d648fe7b6ff0ca9b0bd73950d19952bc1a6534540762c5d79d305c", size = 11950889, upload-time = "2026-05-11T18:52:50.905Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/c5/fc1b368f303087d20e8c9bf3d6ceb186263cfac0ade735cd938538bea839/pandas-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:c7be265b62cef88e253a941e4698604973736dcfe242fdb5198f0f7bc473cdcc", size = 9755463, upload-time = "2026-05-11T18:52:53.386Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/fda8f9705b1b09c6ebe14bfc0fa0e4ec8584d54ea673628f157ff55131af/pandas-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:557409bc4178e70ee8d9ddb494798e51ebf6ea59330f6be22c51bab2a7db6c49", size = 9066158, upload-time = "2026-05-11T18:52:56.038Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" },
+    { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" },
+    { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" },
+    { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/47/e4501f49c178ae1d9f4a75073fda4204f52647993f075a9db4d14930e0c5/platformdirs-4.10.0.tar.gz", hash = "sha256:31e761a6a0ca04faf7353ea759bdba55652be214725111e5aac52dfa29d4bef7", size = 31224, upload-time = "2026-05-28T03:32:53.587Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/e6/cd9575ac904136b3cbf7aa7ee819ef86eedb7274e46f230e94ea4342e729/platformdirs-4.10.0-py3-none-any.whl", hash = "sha256:fb516cdb12eb0d857d0cd85a7c57cea4d060bee4578d6cf5a14dfdf8cbf8784a", size = 22743, upload-time = "2026-05-28T03:32:52.175Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "prometheus-client"
+version = "0.25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/fb/d9aa83ffe43ce1f19e557c0971d04b90561b0cfd50762aafb01968285553/prometheus_client-0.25.0.tar.gz", hash = "sha256:5e373b75c31afb3c86f1a52fa1ad470c9aace18082d39ec0d2f918d11cc9ba28", size = 86035, upload-time = "2026-04-09T19:53:42.359Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/9b/d4b1e644385499c8346fa9b622a3f030dce14cd6ef8a1871c221a17a67e7/prometheus_client-0.25.0-py3-none-any.whl", hash = "sha256:d5aec89e349a6ec230805d0df882f3807f74fd6c1a2fa86864e3c2279059fed1", size = 64154, upload-time = "2026-04-09T19:53:41.324Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/44/c87281c333769159c50594f22610f77398a47ccbfbbf23074e744e86f87c/propcache-0.5.2.tar.gz", hash = "sha256:01c4fc7480cd0598bb4b57022df55b9ca296da7fc5a8760bd8451a7e63a7d427", size = 50208, upload-time = "2026-05-08T21:02:12.199Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/cb/e27bc2b2737a0bb49962b275efa051e8f1c35a936df7d5139b6b658b7dc9/propcache-0.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:806719138ecd720339a12410fb9614ac9b2b2d3a5fdf8235d56981c36f4039ba", size = 95887, upload-time = "2026-05-08T21:00:11.277Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/13/b8ae04c59392f8d11c6cd9fb4011d1dc7c86b81225c770280300e259ffe1/propcache-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:db2b80ea58eab4f86b2beec3cc8b39e8ff9276ac20e96b7cce43c8ae84cd6b5a", size = 54654, upload-time = "2026-05-08T21:00:12.604Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/7d/49777a3e20b55863d4794384a38acd460c04157b0a00f8602b0d508b8431/propcache-0.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e5cbfac9f61484f7e9f3597775500cd3ebe8274e9b050c38f9525c77c97520bf", size = 55190, upload-time = "2026-05-08T21:00:13.935Z" },
+    { url = "https://files.pythonhosted.org/packages/44/c7/085d0cd63062e84044e3f05797749c3f8e3938ff3aeb0eb2f69d43fafc91/propcache-0.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbc581d2814337da56222fab8dc5f161cd798a434e49bac27930aaef798e144", size = 59995, upload-time = "2026-05-08T21:00:15.526Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/42/32cf8e3009e92b2645cf1e944f701e8ea4e924dffde1ee26db860bcbf7e4/propcache-0.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:857187f381f88c8e2fa2fe56ab94879d011b883d5a2ee5a1b60a8cd2a06846d9", size = 63422, upload-time = "2026-05-08T21:00:16.824Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/1b/f112433f99fc979431b87a39ef169e3f8df070d99a72792c56d6937ac48b/propcache-0.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:178b4a2cdaac1818e2bf1c5a99b94383fa73ea5382e032a48dec07dc5668dc42", size = 64342, upload-time = "2026-05-08T21:00:18.362Z" },
+    { url = "https://files.pythonhosted.org/packages/14/15/5574111ae50dd6e879456888c0eadd4c5a869959775854e18e18a6b345f3/propcache-0.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f328175a2cde1f0ff2c4ed8ce968b9dcfb55f3a7153f39e2957ed994da13476", size = 61639, upload-time = "2026-05-08T21:00:19.692Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/da/4d775080b1490c0ae604acda868bd71aabe3a89ed16f2aa4339eb8a283e7/propcache-0.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5671d09a36b06d0fd4a3da0fccbcae360e9b1570924171a15e9e0997f0249fba", size = 61588, upload-time = "2026-05-08T21:00:21.155Z" },
+    { url = "https://files.pythonhosted.org/packages/04/ac/f076982cbe2195ee9cf32de5a1e46951d9fb399fc207f390562dd0fd8fb2/propcache-0.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80168e2ebe4d3ec6599d10ad8f520304ae1cad9b6c5a95372aef1b66b7bfb53a", size = 60029, upload-time = "2026-05-08T21:00:22.713Z" },
+    { url = "https://files.pythonhosted.org/packages/70/60/189be62e0dd898dce3b331e1b8c7a543cd3a405ac0c81fe8ee8a9d5d77e1/propcache-0.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:45f11346f884bc47444f6e6647131055844134c3175b629f84952e2b5cd62b64", size = 56774, upload-time = "2026-05-08T21:00:24.001Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/9e/93377b9c7939c1ffae98f878dee955efadfd638078bc86dbc21f9d52f651/propcache-0.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e778ebd44ef4f66ed60a0416b06b489687db264a9c0b3620362f26489492913", size = 63532, upload-time = "2026-05-08T21:00:25.545Z" },
+    { url = "https://files.pythonhosted.org/packages/14/f9/590ef6cfb9b8028d516d287812ece32bb0bc5f11fbb9c8bf6b2e6313fec8/propcache-0.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c0cb9ed24c8964e172768d455a38254c2dd8a552905729ce006cad3d3dda59b1", size = 61592, upload-time = "2026-05-08T21:00:27.186Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/5e/70958b3034c297a630bba2f17ca7abc2d5f39a803ad7e370ab79d1ecd022/propcache-0.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1d1ad32d9d4355e2be65574fd0bfd3677e7066b009cd5b9b2dee8aa6a6393b33", size = 64788, upload-time = "2026-05-08T21:00:28.8Z" },
+    { url = "https://files.pythonhosted.org/packages/12/fd/77fe5936d8c3086ca9048f7f415f122ed82e53884a9ec193646b42deef06/propcache-0.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c80f4ba3e8f00189165999a742ee526ebeccedf6c3f7beb0c7df821e9772435a", size = 62514, upload-time = "2026-05-08T21:00:30.098Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/74/66bd798b5b3be70aa1b391f5cc9d6a0a5532d7fd3b19ec0b213e72e6ad9d/propcache-0.5.2-cp312-cp312-win32.whl", hash = "sha256:8c7972d8f193740d9175f0998ab38717e6cd322d5935c5b0fef8c0d323fd9031", size = 39018, upload-time = "2026-05-08T21:00:31.622Z" },
+    { url = "https://files.pythonhosted.org/packages/61/7c/5c0d34aa3024694d6dcb9271cdbdd08c4e47c1c0ad95ec7e7bc74cdea145/propcache-0.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:d9ee8826a7d47863a08ac44e1a5f611a462eefc3a194b492da242128bec75b42", size = 42322, upload-time = "2026-05-08T21:00:32.918Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/91/875812f1a3feb20ceba818ef39fbe4d92f1081e04ac815c822496d0d038b/propcache-0.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:2800a4a8ead6b28cccd1ec54b59346f0def7922ee1c7598e8499c733cfbb7c84", size = 38172, upload-time = "2026-05-08T21:00:35.124Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/ed/1cdcab6ba3d6ab7feca11fc14f0eeea80755bb53ef4e892079f31b10a25f/propcache-0.5.2-py3-none-any.whl", hash = "sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe", size = 14036, upload-time = "2026-05-08T21:02:10.673Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "7.35.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/60/fd/5b1491d9e4b586d621c54f4c36b888714164b6875f8d6afa3f9072906a51/protobuf-7.35.0.tar.gz", hash = "sha256:a2efd84605f41e559f1881b0912b44099d0a2ac9bf46b3474823f10fb393b0e6", size = 458677, upload-time = "2026-05-19T23:02:29.197Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/ee/93d06e358a4aa32280b00e722d3ea0a1f25fc3cc5778d80581c9cca2c10e/protobuf-7.35.0-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:66be6c513931c794fa92c080ffee41671390da3d79da219cf9c0c0907f035dda", size = 433225, upload-time = "2026-05-19T23:02:19.884Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/39/1c76c2da93f3c507e958e0aecee2391cc44d4625de6c728bbc555195b5a8/protobuf-7.35.0-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:fcbe42a4ac09d3ec9c987ddfcd956afd0b15f1ff613bd8371bde9405ffd5c8e5", size = 328847, upload-time = "2026-05-19T23:02:22.3Z" },
+    { url = "https://files.pythonhosted.org/packages/91/1a/39f7ce90a238c1a987a4d81ec26379e02ca0aff367de68e4a1fa474215b9/protobuf-7.35.0-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:4cbf5cc286130e06a6c9bbefac442431173906dfcc979712183d4adcc01b37ee", size = 344030, upload-time = "2026-05-19T23:02:23.591Z" },
+    { url = "https://files.pythonhosted.org/packages/70/5b/6baf9008817964454055ff3fe65f1de0b5f1e26c80c82f7fb108b7cd4ea3/protobuf-7.35.0-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:6c0f98f10c8a05ea30f8993dfef2de093d27b490fdae78bb60c8343795d55011", size = 327130, upload-time = "2026-05-19T23:02:24.637Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e5/e46adb0badc388bfb84877a5f9f026aff63f60e611016cf64dbe77e05446/protobuf-7.35.0-cp310-abi3-win32.whl", hash = "sha256:4c4617b83ade0e279d1d2bfe04025a1adb87f9ed657de038620dc0ff959357f6", size = 428946, upload-time = "2026-05-19T23:02:25.741Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/ab/547fbd9e16d879dd13c167478f8ae0a83a428008ca07a5e06acdc23ad473/protobuf-7.35.0-cp310-abi3-win_amd64.whl", hash = "sha256:f05bcadf9a2a6b8dda047007075135fb7d08c73d9177aabc067e1be46881a201", size = 439996, upload-time = "2026-05-19T23:02:26.808Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ef/50433d346c56657a70d27f156c7b349ac59a068b01de4eb796e747eecc43/protobuf-7.35.0-py3-none-any.whl", hash = "sha256:c13f325cf242bad135c350629eeb5d54b24228eb472fb3e2e9ebbd4c5dc20ca0", size = 171659, upload-time = "2026-05-19T23:02:27.842Z" },
+]
+
+[[package]]
+name = "psutil"
+version = "7.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },
+    { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
+    { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
+    { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
+]
+
+[[package]]
+name = "pyarrow"
+version = "24.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/91/13/13e1069b351bdc3881266e11147ffccf687505dbb0ea74036237f5d454a5/pyarrow-24.0.0.tar.gz", hash = "sha256:85fe721a14dd823aca09127acbb06c3ca723efbd436c004f16bca601b04dcc83", size = 1180261, upload-time = "2026-04-21T10:51:25.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/a9/9686d9f07837f91f775e8932659192e02c74f9d8920524b480b85212cc68/pyarrow-24.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:6233c9ed9ab9d1db47de57d9753256d9dcffbf42db341576099f0fd9f6bf4810", size = 34981559, upload-time = "2026-04-21T10:47:22.17Z" },
+    { url = "https://files.pythonhosted.org/packages/80/b6/0ddf0e9b6ead3474ab087ae598c76b031fc45532bf6a63f3a553440fb258/pyarrow-24.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:f7616236ec1bc2b15bfdec22a71ab38851c86f8f05ff64f379e1278cf20c634a", size = 36663654, upload-time = "2026-04-21T10:47:28.315Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/3b/926382efe8ce27ba729071d3566ade6dfb86bdf112f366000196b2f5780a/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:1617043b99bd33e5318ae18eb2919af09c71322ef1ca46566cdafc6e6712fb66", size = 45679394, upload-time = "2026-04-21T10:47:34.821Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/7a/829f7d9dfd37c207206081d6dad474d81dde29952401f07f2ba507814818/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6165461f55ef6314f026de6638d661188e3455d3ec49834556a0ebbdbace18bb", size = 48863122, upload-time = "2026-04-21T10:47:42.056Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e8/f88ce625fe8babaae64e8db2d417c7653adb3019b08aae85c5ed787dc816/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b13dedfe76a0ad2d1d859b0811b53827a4e9d93a0bcb05cf59333ab4980cc7e", size = 49376032, upload-time = "2026-04-21T10:47:48.967Z" },
+    { url = "https://files.pythonhosted.org/packages/36/7a/82c363caa145fff88fb475da50d3bf52bb024f61917be5424c3392eaf878/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:25ea65d868eb04015cd18e6df2fbe98f07e5bda2abefabcb88fce39a947716f6", size = 51929490, upload-time = "2026-04-21T10:47:55.981Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1c/e3e72c8014ad2743ca64a701652c733cc5cbcee15c0463a32a8c55518d9e/pyarrow-24.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:295f0a7f2e242dabd513737cf076007dc5b2d59237e3eca37b05c0c6446f3826", size = 27355660, upload-time = "2026-04-21T10:48:01.718Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.13.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.46.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" },
+    { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" },
+    { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" },
+    { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" },
+    { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" },
+    { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" },
+    { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" },
+    { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pyparsing"
+version = "3.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.34.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
+]
+
+[[package]]
+name = "rich"
+version = "15.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.15"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/84/6f/a76f7d96e5c962f5b69cee865e49c15c1116897c01990faa8a57edb62e7f/ruff-0.15.15.tar.gz", hash = "sha256:b8dff018130b46d8e5bf0f926ef6b60cf871d6d5ae45fc9334e09632daa741d6", size = 4706985, upload-time = "2026-05-28T14:16:57.784Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/9d/3a45c05b8ab04b4705989de70a79008e27c8003296a0feaee9edc18dd7e9/ruff-0.15.15-py3-none-linux_armv6l.whl", hash = "sha256:cf93e5388f412e1b108b1f8b34a6e036b70fe8aff89393befad96fe48670311b", size = 10710652, upload-time = "2026-05-28T14:16:06.701Z" },
+    { url = "https://files.pythonhosted.org/packages/05/66/da974431624bf3b49f6ee1f9543c02d929ff1cba78b0d5a79c38cf21f744/ruff-0.15.15-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ac5a646d1f6a7dadd5d50842dae2c1f9862ac887ef5d1b1375e02def791fde6e", size = 11096615, upload-time = "2026-05-28T14:16:23.313Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/09/7443452e5d290230a712103f2fdceeef7184f3ec99a2bd01c8be78aaceb5/ruff-0.15.15-py3-none-macosx_11_0_arm64.whl", hash = "sha256:77d955a431430c66f72dd94e379ad38a16daea3d25094872ac4edf9e797be530", size = 10436683, upload-time = "2026-05-28T14:16:40.974Z" },
+    { url = "https://files.pythonhosted.org/packages/53/01/d330c26a57fa4f3943a14424904027428315b700fe4d14a84bb123a649e5/ruff-0.15.15-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7614ee79c69788cf6cedd568069ade9cecc22a1ad20494efe8d0c9ebb4b622d4", size = 10769064, upload-time = "2026-05-28T14:16:28.905Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/85/cc8770f8bdff541b1da8392d1634141fe4a0e3f4ee596605959b7906c27f/ruff-0.15.15-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3cdb1679e06a1f6b47bc384714ae96f6e2fb65ca441eb78c43d2ca554176ce1f", size = 10511987, upload-time = "2026-05-28T14:16:43.732Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/29/8c190c1472b63013583ba391f3342036e02010544c1270455ed8e519bdf3/ruff-0.15.15-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2728b93d7b23a603ea2c0ac6eb73d760bd38ec9de35f35fb41e18f7a3fee7622", size = 11275100, upload-time = "2026-05-28T14:16:55.244Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/6b/7e145ce2cc8e63d6834eca03d83a0e18d121def5c69f91b4cf4011ed4879/ruff-0.15.15-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be582fcc0db438902c7792b08d6ddf6c9b9e21addaa10092c2c741cfb09e5a45", size = 12176903, upload-time = "2026-05-28T14:16:14.368Z" },
+    { url = "https://files.pythonhosted.org/packages/80/a3/d5974637f68e451f7fadf015cf3101d1cd7d8ba5027cffe0b9e3826ebe6b/ruff-0.15.15-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7aa77465b8ecaf1a27bea098d696f7fed5e1eccbd10b321b682d6de586ae5627", size = 11404550, upload-time = "2026-05-28T14:16:20.138Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/1c/e6e5e568f22be4fb05d6244234aba384c06b451252453b821e1a529263cf/ruff-0.15.15-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48decfa11d740de4889de623be1463308346312f2409a56e24aa280c86162dc4", size = 11382027, upload-time = "2026-05-28T14:16:46.615Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/01/170921b49fcd2e8858825593f91cf7146c3e40a5c3e6df763e4bb0484dde/ruff-0.15.15-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a5015088452ca0081387063649ec67f06d3d1d6b8b936a1f836b5e9657ecd48c", size = 11366041, upload-time = "2026-05-28T14:16:26.247Z" },
+    { url = "https://files.pythonhosted.org/packages/87/54/a7bad711d7de93254e15e06a4c375b89a03d18de45d3e5dcc86a4472fb1a/ruff-0.15.15-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:f5294aab6356c81600fcdea3a62bb1b924dfd5e91767c12318d3f68f86af57cd", size = 10741795, upload-time = "2026-05-28T14:16:17.11Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/31/38c075963668f8b41c6914ee0f6f318727fbe30ab9145cb29e6df464c5fa/ruff-0.15.15-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:db5bd4d802415cca656dc1616070b725952d6ae95eb5d4831e49fbd94a38f75f", size = 10511117, upload-time = "2026-05-28T14:16:31.767Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/96/6ff689e1f7e375d1d97075eca022f74c2bab59554a432fe4d2e6f091986a/ruff-0.15.15-py3-none-musllinux_1_2_i686.whl", hash = "sha256:587a6278ed42059191c1a466e490bd7930fb50bd2e255398bc29616c895a61cb", size = 10994867, upload-time = "2026-05-28T14:16:35.149Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c2/5dce0ab9f92a8d534fa62b9bf9caca3eddb8c1a81b616f5e195ada4f0d6e/ruff-0.15.15-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:df0c1c084f5f4be9812f61518a45c440d3c30d69ce4bf6c5270e66d38338f02a", size = 11482101, upload-time = "2026-05-28T14:16:49.598Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/c0/1003b60edd697c649faf61f1a34094b1abb38fb3d1181e3f895781250a08/ruff-0.15.15-py3-none-win32.whl", hash = "sha256:29428ea79694afbe756d45fd59b36f22b6b020dc0443cf7de0173046236964b9", size = 10716774, upload-time = "2026-05-28T14:16:52.337Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a8/1269eddd6945a06c23f055ef7848886e37cf9d6a8bebb386a3115f01470c/ruff-0.15.15-py3-none-win_amd64.whl", hash = "sha256:8df0323902e15e24bc4bf246da830573d3cf3352bd0b9a164eab335d111ff4a4", size = 11868463, upload-time = "2026-05-28T14:16:11.333Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/b2/920464c907b191e37469d477a1aa8bc048b8f36c4c1610dfa4ab87b39e18/ruff-0.15.15-py3-none-win_arm64.whl", hash = "sha256:3c8ceca6792f38196b8f589bc92eccd03eef286602da92e5dc05cc42ef6441b7", size = 11138498, upload-time = "2026-05-28T14:16:38.425Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.17.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/35/48/b992b488d6f299dbe3f11a20b24d3dda3d46f1a635ede1c46b5b17a7b163/scipy-1.17.1-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:35c3a56d2ef83efc372eaec584314bd0ef2e2f0d2adb21c55e6ad5b344c0dcb8", size = 31610954, upload-time = "2026-02-23T00:17:49.855Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/02/cf107b01494c19dc100f1d0b7ac3cc08666e96ba2d64db7626066cee895e/scipy-1.17.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:fcb310ddb270a06114bb64bbe53c94926b943f5b7f0842194d585c65eb4edd76", size = 28172662, upload-time = "2026-02-23T00:18:01.64Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/a9/599c28631bad314d219cf9ffd40e985b24d603fc8a2f4ccc5ae8419a535b/scipy-1.17.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:cc90d2e9c7e5c7f1a482c9875007c095c3194b1cfedca3c2f3291cdc2bc7c086", size = 20344366, upload-time = "2026-02-23T00:18:12.015Z" },
+    { url = "https://files.pythonhosted.org/packages/35/f5/906eda513271c8deb5af284e5ef0206d17a96239af79f9fa0aebfe0e36b4/scipy-1.17.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:c80be5ede8f3f8eded4eff73cc99a25c388ce98e555b17d31da05287015ffa5b", size = 22704017, upload-time = "2026-02-23T00:18:21.502Z" },
+    { url = "https://files.pythonhosted.org/packages/da/34/16f10e3042d2f1d6b66e0428308ab52224b6a23049cb2f5c1756f713815f/scipy-1.17.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21", size = 32927842, upload-time = "2026-02-23T00:18:35.367Z" },
+    { url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458", size = 35235890, upload-time = "2026-02-23T00:18:49.188Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/5c/9d7f4c88bea6e0d5a4f1bc0506a53a00e9fcb198de372bfe4d3652cef482/scipy-1.17.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8a604bae87c6195d8b1045eddece0514d041604b14f2727bbc2b3020172045eb", size = 35003557, upload-time = "2026-02-23T00:18:54.74Z" },
+    { url = "https://files.pythonhosted.org/packages/65/94/7698add8f276dbab7a9de9fb6b0e02fc13ee61d51c7c3f85ac28b65e1239/scipy-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f590cd684941912d10becc07325a3eeb77886fe981415660d9265c4c418d0bea", size = 37625856, upload-time = "2026-02-23T00:19:00.307Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/84/dc08d77fbf3d87d3ee27f6a0c6dcce1de5829a64f2eae85a0ecc1f0daa73/scipy-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:41b71f4a3a4cab9d366cd9065b288efc4d4f3c0b37a91a8e0947fb5bd7f31d87", size = 36549682, upload-time = "2026-02-23T00:19:07.67Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/98/fe9ae9ffb3b54b62559f52dedaebe204b408db8109a8c66fdd04869e6424/scipy-1.17.1-cp312-cp312-win_arm64.whl", hash = "sha256:f4115102802df98b2b0db3cce5cb9b92572633a1197c77b7553e5203f284a5b3", size = 24547340, upload-time = "2026-02-23T00:19:12.024Z" },
+]
+
+[[package]]
+name = "sentry-sdk"
+version = "2.61.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/4d/3c66e6045bd2071256b6b6fdcb0cc02b86ce54b2acc2ceac79af8e0efbb5/sentry_sdk-2.61.0.tar.gz", hash = "sha256:1ca9b4bb777eb5be67004edab7eb894f21c6301f1d05ed64966719ad5d1764ce", size = 458510, upload-time = "2026-05-28T09:40:28.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/21/5a/9794736d5802689c1a48862e6afe6b7f3e86cc37c15d4a84bc0143877dc1/sentry_sdk-2.61.0-py3-none-any.whl", hash = "sha256:ec4d30273909cb1d198e03208b16ee70e2bc5d90a16fd9f1fb2fc6a72e1f03dc", size = 483111, upload-time = "2026-05-28T09:40:27.027Z" },
+]
+
+[[package]]
+name = "sheaf-admm"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "datasets" },
+    { name = "flax" },
+    { name = "huggingface-hub" },
+    { name = "hydra-core" },
+    { name = "jax" },
+    { name = "jax", extra = ["cuda12"], marker = "sys_platform == 'linux'" },
+    { name = "matplotlib" },
+    { name = "ml-datasets" },
+    { name = "numpy" },
+    { name = "omegaconf" },
+    { name = "optax" },
+    { name = "pillow" },
+    { name = "wandb" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "datasets", specifier = "==4.8.5" },
+    { name = "flax", specifier = "==0.12.7" },
+    { name = "huggingface-hub", specifier = "==1.17.0" },
+    { name = "hydra-core", specifier = "==1.3.2" },
+    { name = "jax", marker = "sys_platform != 'linux'", specifier = "==0.10.1" },
+    { name = "jax", extras = ["cuda12"], marker = "sys_platform == 'linux'", specifier = "==0.10.1" },
+    { name = "matplotlib", specifier = "==3.10.9" },
+    { name = "ml-datasets", specifier = "==0.2.1" },
+    { name = "numpy", specifier = "==2.4.6" },
+    { name = "omegaconf", specifier = "==2.3.0" },
+    { name = "optax", specifier = "==0.2.8" },
+    { name = "pillow", specifier = "==12.2.0" },
+    { name = "wandb", specifier = "==0.27.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest", specifier = "==9.0.3" },
+    { name = "ruff", specifier = "==0.15.15" },
+]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
+]
+
+[[package]]
+name = "simplejson"
+version = "4.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0e/2a/54837395a3487c725669428d513293612a48d82b95a0642c936932e5d898/simplejson-4.1.1.tar.gz", hash = "sha256:c08eb9f7a90f77ae470e19a07472e9a79ebc0d1c2315d86a72767665bd5ba79f", size = 118860, upload-time = "2026-04-24T19:24:59.819Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/25/e90998fe8e480eb43b966c09e835379887d427567ebd496563d3b1e16b19/simplejson-4.1.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:19040a17154dc03d289bab68d73ce0a6a0be01de30c584bbdd93490bead14b22", size = 112414, upload-time = "2026-04-24T19:23:06.084Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a0/abd4785f36c3400f1fbb21f517be39295a750a714f04b7ee175adf6ef580/simplejson-4.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a94ebaecdbaa80d9551a3ec6bf0c9302fc8b53ab6c1b2bfd498a1df4cb28158d", size = 91120, upload-time = "2026-04-24T19:23:07.877Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/78/fc060d2e3b13c6ec59288574b8efac64075e316b2afba4396a56b2422f78/simplejson-4.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:67341c95c0a168ab4a6d1e807e50463f1c8da932c3286d81e201266c427061fa", size = 91055, upload-time = "2026-04-24T19:23:09.264Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b6/156a8de1e1b47694f0e7de6675866936608d45dc68388fd017d36f8693be/simplejson-4.1.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:45ec18e337fec538b7e902d489505c450b2454653d1290f3f50385e6fd8aa607", size = 190297, upload-time = "2026-04-24T19:23:11.226Z" },
+    { url = "https://files.pythonhosted.org/packages/86/1c/e4d0eab695be3eb21d0f46bce820752031f03e7113f9c80a9b3c73ee7157/simplejson-4.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:820c69a4710400e9b248d5670647d60be58824369282d3925e516b3ff1a7cd82", size = 187002, upload-time = "2026-04-24T19:23:12.982Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0e/7f5a59d29426b062d5928fb88b403c3f797129d53be7102f955dbe51aa44/simplejson-4.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e708d373a10e4378ef2d59f8361850c7150fd907ed49efe49bc5492160476d1", size = 195146, upload-time = "2026-04-24T19:23:14.517Z" },
+    { url = "https://files.pythonhosted.org/packages/78/18/9943db224dd4d5fa3c090c3e56a94c37b254338c83995ec5680285111c40/simplejson-4.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:980fc33353f81fd12d8c49d44f8c2760d1dc8192285e627c5180d141035b228a", size = 183931, upload-time = "2026-04-24T19:23:16.742Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/08/9a690da9a766161c06c627d805362cf159f1abe480969372b2897649b955/simplejson-4.1.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:de2ed102fff88dacf543699f53ee3a533cc11539a39baa176b7e09dd783069d6", size = 192228, upload-time = "2026-04-24T19:23:18.33Z" },
+    { url = "https://files.pythonhosted.org/packages/05/88/bd8aad36b451ffb0e0a3f721d695a88befa6d1ac7d1e02ae788ca7ff4029/simplejson-4.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2785ff8edc0e28bf773a32543a6bbed46351453c997b3f6709c744e3c2f7eabb", size = 187808, upload-time = "2026-04-24T19:23:21.165Z" },
+    { url = "https://files.pythonhosted.org/packages/04/ee/14f91db0d1f481533b651dafbf8cd0da088d9817f7af30c68f7f19f9c847/simplejson-4.1.1-cp312-cp312-win32.whl", hash = "sha256:2e0d5ead6d14610467ec356ec1f6b5d8a56aa216abaad8d41c8b873b16cf313f", size = 88512, upload-time = "2026-04-24T19:23:22.764Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/c4/90de06b2d8737c68c05ff9274113f854dbf6a5f28b7a955212111672cb57/simplejson-4.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:63a5451f557d6be48a231bae932458655c620902b868170b2f1c8afed496f6b4", size = 90748, upload-time = "2026-04-24T19:23:24.494Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/6a/8b74c52ffd33dbbde00fe7251fee6a0acdc8cea33f7a43805aed258fb79b/simplejson-4.1.1-py3-none-any.whl", hash = "sha256:2ce92b3748f02423e26d2bfb636fb9d7a8f67c8f5854dcae69d350d123b2eee2", size = 69195, upload-time = "2026-04-24T19:24:57.962Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "smmap"
+version = "5.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1f/ea/49c993d6dfdd7338c9b1000a0f36817ed7ec84577ae2e52f890d1a4ff909/smmap-5.0.3.tar.gz", hash = "sha256:4d9debb8b99007ae47165abc08670bd74cb74b5227dda7f643eccc4e9eb5642c", size = 22506, upload-time = "2026-03-09T03:43:26.1Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/d4/59e74daffcb57a07668852eeeb6035af9f32cbfd7a1d2511f17d2fe6a738/smmap-5.0.3-py3-none-any.whl", hash = "sha256:c106e05d5a61449cf6ba9a1e650227ecfb141590d2a98412103ff35d89fc7b2f", size = 24390, upload-time = "2026-03-09T03:43:24.361Z" },
+]
+
+[[package]]
+name = "srsly"
+version = "2.5.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "catalogue" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2b/db/f794f219a6c788b881252d2536a8c4a97d2bdaadc690391e1cb53d123d71/srsly-2.5.3.tar.gz", hash = "sha256:08f98dbecbff3a31466c4ae7c833131f59d3655a0ad8ac749e6e2c149e2b0680", size = 490881, upload-time = "2026-03-23T11:56:59.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/cc/e9f7fcec4cc92ad8bad6316c4241638b8cf7380382d4489d94ec6c436452/srsly-2.5.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:71e51c046ccbeefb86524c6b1e17574f579c6ac4dc8ea4a09437d3e8f88342d3", size = 658379, upload-time = "2026-03-23T11:55:59.85Z" },
+    { url = "https://files.pythonhosted.org/packages/21/e4/fea4512e9785f58509b2cf67d993323848e583161b5fcfdc7dd9d7c1f3df/srsly-2.5.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f73c0db911552e94fe2016e1759d261d2f47926f68826664cada3723c87006a", size = 658513, upload-time = "2026-03-23T11:56:01.239Z" },
+    { url = "https://files.pythonhosted.org/packages/20/b1/53591681b6ff2699a4f97b2d5552ba196eaa6a979b0873605f4c04b5f7ee/srsly-2.5.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c1ac27ae5f4bb9163c7d2c45fc8ec173aac3d92e32086d9472b326c5c6e570e", size = 1172265, upload-time = "2026-03-23T11:56:02.589Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/c9/741e29f534919a944a16da4184924b1d3404c4bf60716ab2b91be771d1e3/srsly-2.5.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:99026bcd9cbd3211cc36517400b04ca0fc5d3e412b14daf84ee6e65f67d9a2d8", size = 1180873, upload-time = "2026-03-23T11:56:03.944Z" },
+    { url = "https://files.pythonhosted.org/packages/89/57/5554f786eccf78b2750d6ac63be126e1b67badec2cb409dd611cf6f8c52b/srsly-2.5.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:07d682679e639eb46ff7e6da4a92714f4d5ffe351d088ee66f221e9b1f8865bb", size = 1120437, upload-time = "2026-03-23T11:56:05.283Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/95/9b4f73b1be3692f86d72ccc131c8e50f26f824d5c8830a59390bcc5b60ef/srsly-2.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8e0542d85d6b55cf2934050d6ffcb1cd76c768dcf9572e7467002cf087bb366d", size = 1137376, upload-time = "2026-03-23T11:56:06.613Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/de/89ca640ca1953c4612279ce515d0af35658df3c06cdb324329bc91b4a7e1/srsly-2.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:598f1e494c18cacb978299d77125415a586417081959f8ec3f068b32d97f8933", size = 652459, upload-time = "2026-03-23T11:56:07.994Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/4f/7ab6d49e36d9cc72ee15746cabd116eb6f338be8a06c1882968ee9d6c7d7/srsly-2.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:4b1b721cd3ad1a9b2343519aadc786a4d09d5c0666962d49852eb12d6ec3fe26", size = 638411, upload-time = "2026-03-23T11:56:09.31Z" },
+]
+
+[[package]]
+name = "tensorstore"
+version = "0.1.84"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ml-dtypes" },
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/83/18/c8e8b4faffab1a434b6c013d54cf7f5b754a6849429d9dbb718297705796/tensorstore-0.1.84.tar.gz", hash = "sha256:3cb091dfde68600e6d8f03a389ccc92ffa7c0798a0c600d1013c0138d7163e6b", size = 7208048, upload-time = "2026-05-16T06:17:58.448Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/8a/1b5231e965257c3ee7d4615cb49a0fac53a71a1c34b293bcf524bb7c6d13/tensorstore-0.1.84-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:915371fc2c27540e8b69c573b7a06217fb8d161ec231cedfa9f3d264615a326d", size = 16571584, upload-time = "2026-05-16T06:17:13.283Z" },
+    { url = "https://files.pythonhosted.org/packages/88/5d/52e52aa00a5ae3ebe1116ca52ac9f47ef98e94f6c4e411649cd3d1bb79cc/tensorstore-0.1.84-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4477eabe26e2f5131f1b1a3444cd9167fe69fabc29579eab8259d218399b9e6b", size = 14905169, upload-time = "2026-05-16T06:17:15.638Z" },
+    { url = "https://files.pythonhosted.org/packages/61/36/f88b4bf267902f12cd2ca33aff10fabd6839dd1ce7d51876ebefa98aaf2c/tensorstore-0.1.84-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ace00cf2e45dc5d64fe3a10c2cbef61343915683808a10a3e081233566a7231", size = 19345134, upload-time = "2026-05-16T06:17:17.984Z" },
+    { url = "https://files.pythonhosted.org/packages/18/7c/b7b24e10e5cb0213c85204d53fcd60d0568d986ea0001a00a815e14e01e1/tensorstore-0.1.84-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:64c8039558d5607b73903948fce058725731df410c5c196cf58b3fc6222395b5", size = 20968745, upload-time = "2026-05-16T06:17:20.569Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/36/33ad454a2b667a93b35e74595a351dbf9b8693440bd68665990663b79164/tensorstore-0.1.84-cp312-cp312-win_amd64.whl", hash = "sha256:08e7ec5b35db5d4c4b6a867be8500448f9bd4e0c9d5a52d7f0b460650622baf6", size = 13398458, upload-time = "2026-05-16T06:17:22.701Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" },
+]
+
+[[package]]
+name = "treescope"
+version = "0.1.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f0/2a/d13d3c38862632742d2fe2f7ae307c431db06538fd05ca03020d207b5dcc/treescope-0.1.10.tar.gz", hash = "sha256:20f74656f34ab2d8716715013e8163a0da79bdc2554c16d5023172c50d27ea95", size = 138870, upload-time = "2025-08-08T05:43:48.048Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/2b/36e984399089c026a6499ac8f7401d38487cf0183839a4aa78140d373771/treescope-0.1.10-py3-none-any.whl", hash = "sha256:dde52f5314f4c29d22157a6fe4d3bd103f9cae02791c9e672eefa32c9aa1da51", size = 182255, upload-time = "2025-08-08T05:43:46.673Z" },
+]
+
+[[package]]
+name = "typer"
+version = "0.25.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "click" },
+    { name = "rich" },
+    { name = "shellingham" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/51/9aed62104cea109b820bbd6c14245af756112017d309da813ef107d42e7e/typer-0.25.1.tar.gz", hash = "sha256:9616eb8853a09ffeabab1698952f33c6f29ffdbceb4eaeecf571880e8d7664cc", size = 122276, upload-time = "2026-04-30T19:32:16.964Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/f9/2b3ff4e56e5fa7debfaf9eb135d0da96f3e9a1d5b27222223c7296336e5f/typer-0.25.1-py3-none-any.whl", hash = "sha256:75caa44ed46a03fb2dab8808753ffacdbfea88495e74c85a28c5eefcf5f39c89", size = 58409, upload-time = "2026-04-30T19:32:18.271Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "tzdata"
+version = "2026.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", hash = "sha256:9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10", size = 198254, upload-time = "2026-04-24T15:22:08.651Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+]
+
+[[package]]
+name = "uvloop"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
+]
+
+[[package]]
+name = "wandb"
+version = "0.27.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "gitpython" },
+    { name = "packaging" },
+    { name = "platformdirs" },
+    { name = "protobuf" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "sentry-sdk" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8e/31/fe53d06b75ef0a7f2f0ee5931a89f7aedc27d233840b1839616860fed256/wandb-0.27.0.tar.gz", hash = "sha256:579e75300173059f9334e1f513a79ef15f6d9ea5c74e20d695633648cdd02031", size = 41090732, upload-time = "2026-05-14T03:44:08.894Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ea/5e/2c199e70e636ecfd217cde0bc7469f4511e1d03d0685eb92bfdfce391430/wandb-0.27.0-py3-none-macosx_12_0_arm64.whl", hash = "sha256:c156be4851485f3c4160cb6eb2e8991b4cdeffbccefc5636d33cf5e254847365", size = 24886476, upload-time = "2026-05-14T03:43:27.569Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/cd/a617c871cd304a9804e56a7ec2ec2c65685bf0091a2b9f91910175a149e2/wandb-0.27.0-py3-none-macosx_12_0_x86_64.whl", hash = "sha256:20179f38afb0158859a4141d29ac650d3fdbd0cf801a74ce25565c934f03776c", size = 26045779, upload-time = "2026-05-14T03:43:31.999Z" },
+    { url = "https://files.pythonhosted.org/packages/10/0a/d3f159a201530b84b72ca5f98c68d1f351c2d9a1864558ed76c811407fae/wandb-0.27.0-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:626497d7975fa898d0a4a239da7a510483495ca3514510dbe75004a25963af4d", size = 25480764, upload-time = "2026-05-14T03:43:35.922Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6a/8721fcdf71d42639191040a77a585d2982402b1754700cb2ecfc2ca1470a/wandb-0.27.0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:f772da7005cc26a2a32b729a16982a583dc68b3d493df6a09d0aa5c5ca5a2060", size = 27256204, upload-time = "2026-05-14T03:43:39.765Z" },
+    { url = "https://files.pythonhosted.org/packages/00/5e/279d167ba79fb7a8a43401c9f25efd0f6663ee9bd1eaf5a8578530198888/wandb-0.27.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:63acfc5b994e4a90e4a2fbdee6d45e664da3dd865bb1419942c8995c06c41cf1", size = 25647469, upload-time = "2026-05-14T03:43:44.817Z" },
+    { url = "https://files.pythonhosted.org/packages/94/51/a69ac59300e3c813939d0764348959ed2a21e14c668cb1cebcb04010da6a/wandb-0.27.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:17aae6e4a88cd05c00ea8f546220918e3ebb6f8c1c36b70ef04a5ac75f0d7160", size = 27599005, upload-time = "2026-05-14T03:43:50.926Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/40/bf510c8758727df020f83b717ebc1fcc1739ed7f6ae1796ebef60bf6f592/wandb-0.27.0-py3-none-win32.whl", hash = "sha256:0bd5659417e386bf6538b5e2ffe6885774c6197f0e4853bfed517d5b0db457f1", size = 25036164, upload-time = "2026-05-14T03:43:54.839Z" },
+    { url = "https://files.pythonhosted.org/packages/54/ff/69f88e7d90c22b79bcb911143c13e59742ee192080b21015ff83a5a1f60a/wandb-0.27.0-py3-none-win_amd64.whl", hash = "sha256:89d584b73166eecee96fb446f18d0e45b1aa45aba6a3696296f3f06d7454516b", size = 25036170, upload-time = "2026-05-14T03:43:59.227Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/38/f7efd7a87297a55c7e9a331a1dbb5b19e54aeacc11fe6f43f8636a73987c/wandb-0.27.0-py3-none-win_arm64.whl", hash = "sha256:a6c129c311edf210a2b4f2f4acc557eff522628125f5f28ed27df19c16c07079", size = 22972710, upload-time = "2026-05-14T03:44:03.275Z" },
+]
+
+[[package]]
+name = "xxhash"
+version = "3.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", hash = "sha256:6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae", size = 82022, upload-time = "2026-04-25T11:10:32.553Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/8a/51a14cdef4728c6c2337db8a7d8704422cc65676d9199d77215464c880af/xxhash-3.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:082c87bfdd2b9f457606c7a4a53457f4c4b48b0cdc48de0277f4349d79bb3d7a", size = 33357, upload-time = "2026-04-25T11:06:20.44Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/1b/0c2c933809421ffd9bf42b59315552c143c755db5d9a816b2f1ae273e884/xxhash-3.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5e7ce913b61f35b0c1c839a49ac9c8e75dd8d860150688aed353b0ce1bf409d8", size = 30869, upload-time = "2026-04-25T11:06:21.989Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/89d5fdd6ee12d70ba99451de46dd0e8010167468dcd913ec855653f4dd50/xxhash-3.7.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3beb1de3b1e9694fcdd853e570ee64c631c7062435d2f8c69c1adf809bc086f0", size = 194100, upload-time = "2026-04-25T11:06:23.586Z" },
+    { url = "https://files.pythonhosted.org/packages/87/ee/2f9f2ed993e77206d1e66991290a1ebe22e843351ca3ebec8e49e01ba186/xxhash-3.7.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3e7b689c3bce16699efcf736066f5c6cc4472c3840fe4b22bd8279daf4abdac", size = 212977, upload-time = "2026-04-25T11:06:25.019Z" },
+    { url = "https://files.pythonhosted.org/packages/de/60/5a91644615a9e9d4e42c2e9925f1908e3a24e4e691d9de7340d565bea024/xxhash-3.7.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a6545e6b409e3d5cbafc850fb84c55a1ca26ed15a6b11e3bf07a0e0cd84517c8", size = 236373, upload-time = "2026-04-25T11:06:26.482Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c0/f3a9384eaaed9d14d4d062a5d953aa0da489bfe9747877aa994caa87cd0b/xxhash-3.7.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:31ab1461c77a11461d703c88eb949e132a1c6515933cf675d97ec680f4bd18de", size = 212229, upload-time = "2026-04-25T11:06:28.065Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/67/02f07a9fd79726804190f2172c4894c3ed9a4ebccaca05653c84beb58025/xxhash-3.7.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7c4d596b7676f811172687ec567cbafb9e4dea2f9be1bbb4f622410cb7f40f40", size = 445462, upload-time = "2026-04-25T11:06:30.048Z" },
+    { url = "https://files.pythonhosted.org/packages/40/37/558f5a90c0672fc9b4402dc25d87ac5b7406616e8969430c9ca4e52ee74d/xxhash-3.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13805f0461cba0a857924e70ff91ae6d52d2598f79a884e788db80532614a4a1", size = 193932, upload-time = "2026-04-25T11:06:31.857Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/90/aaa09cd58661d32044dbbad7df55bbe22a623032b810e7ed3b8c569a2a6f/xxhash-3.7.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1d398f372496152f1c6933a33566373f8d1b37b98b8c9d608fa6edc0976f23b2", size = 284807, upload-time = "2026-04-25T11:06:33.697Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f3/53df3719ab127a02c174f0c1c74924fcd110866e89c966bc7909cfa8fa84/xxhash-3.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d610aa62cdb7d4d497740741772a24a794903bf3e79eaa51d2e800082abe11e5", size = 210445, upload-time = "2026-04-25T11:06:35.488Z" },
+    { url = "https://files.pythonhosted.org/packages/72/33/d219975c0e8b6fa2eb9ccd486fe47e21bf1847985b878dd2fbc3126e0d5c/xxhash-3.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:073c23900a9fbf3d26616c17c830db28af9803677cd5b33aea3224d824111514", size = 241273, upload-time = "2026-04-25T11:06:37.24Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/50/49b1afe610eb3964cedcb90a4d4c3d46a261ee8669cbd4f060652619ae3c/xxhash-3.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:418a463c3e6a590c0cdc890f8be19adb44a8c8acd175ca5b2a6de77e61d0b386", size = 197950, upload-time = "2026-04-25T11:06:39.148Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/75/5f42a1a4c78717d906a4b6a140c6dbf837ab1f547a54d23c4e2903310936/xxhash-3.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:03f8ff4474ee61c845758ce00711d7087a770d77efb36f7e74a6e867301000b8", size = 210709, upload-time = "2026-04-25T11:06:40.958Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/85/237e446c25abced71e9c53d269f2cef5bab8a82b3f88a12e00c5368e7368/xxhash-3.7.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:44fba4a5f1d179b7ddc7b3dc40f56f9209046421679b57025d4d8821b376fd8d", size = 275345, upload-time = "2026-04-25T11:06:42.525Z" },
+    { url = "https://files.pythonhosted.org/packages/62/34/c2c26c0a6a9cc739bc2a5f0ae03ba8b87deb12b8bce35f7ac495e790dc6d/xxhash-3.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31e3516a0f829d06ded4a2c0f3c7c5561993256bfa1c493975fb9dc7bfa828a1", size = 414056, upload-time = "2026-04-25T11:06:44.343Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/aa/5c58e9bc8071b8afd8dcf297ff362f723c4892168faba149f19904132bf4/xxhash-3.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b59ee2ac81de57771a09ecad09191e840a1d2fae1ef684208320591055768f83", size = 191485, upload-time = "2026-04-25T11:06:46.262Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/69/a929cf9d1e2e65a48b818cdce72cb6b69eab2e6877f21436d0a1942aff43/xxhash-3.7.0-cp312-cp312-win32.whl", hash = "sha256:74bbd92f8c7fcc397ba0a11bfdc106bc72ad7f11e3a60277753f87e7532b4d81", size = 30671, upload-time = "2026-04-25T11:06:48.039Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/1b/104b41a8947f4e1d4a66ce1e628eea752f37d1890bfd7453559ca7a3d950/xxhash-3.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:7bd7bc82dd4f185f28f35193c2e968ef46131628e3cac62f639dadf321cba4d1", size = 31514, upload-time = "2026-04-25T11:06:49.279Z" },
+    { url = "https://files.pythonhosted.org/packages/98/a0/1fd0ea1f1b886d9e7c73f0397571e22333a7d79e31da6d7127c2a4a71d75/xxhash-3.7.0-cp312-cp312-win_arm64.whl", hash = "sha256:7d7148180ec99ba36585b42c8c5de25e9b40191613bc4be68909b4d25a77a852", size = 27761, upload-time = "2026-04-25T11:06:50.448Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.24.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/79/12/1e8f37460ea0f7eb59c221fdaf0ed75e7ac43e97f8093b9c6f411df50a78/yarl-1.24.2.tar.gz", hash = "sha256:9ac374123c6fd7abf64d1fec93962b0bd4ee2c19751755a762a72dd96c0378f8", size = 210798, upload-time = "2026-05-19T21:31:05.599Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f0/da/866bcb01076ba49d2b42b309867bed3826421f1c479655eb7a607b44f20b/yarl-1.24.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b975866c184564c827e0877380f0dae57dcca7e52782128381b72feff6dfceb8", size = 129957, upload-time = "2026-05-19T21:28:51.695Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/1d/fcefb70922ea2268a8971d8e5874d9a8218644200fb8465f1dcad55e6851/yarl-1.24.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3b075301a2836a0e297b1b658cb6d6135df535d62efefdd60366bd589c2c82f2", size = 92164, upload-time = "2026-05-19T21:28:53.242Z" },
+    { url = "https://files.pythonhosted.org/packages/29/b6/170e2b8d4e3bc30e6bfdcca53556537f5bf595e938632dfcb059311f3ff6/yarl-1.24.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8ae44649b00947634ab0dab2a374a638f52923a6e67083f2c156cd5cbd1a881d", size = 91688, upload-time = "2026-05-19T21:28:54.865Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/a5/c9f655d5553ea0b99fdac9d6a99ad3f9b3e73b8e5758bb46f58c9831f74c/yarl-1.24.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:507cc19f0b45454e2d6dcd62ff7d062b9f77a2812404e62dbdaec05b50faa035", size = 102902, upload-time = "2026-05-19T21:28:56.963Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/bc/6b9664d815d79af4ee553337f9d606c56bbf269186ada9172de45f1b5f60/yarl-1.24.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c4c17bad5a530912d2111825d3f05e89bab2dd376aaa8cbc77e449e6db63e576", size = 97931, upload-time = "2026-05-19T21:28:58.56Z" },
+    { url = "https://files.pythonhosted.org/packages/98/ec/32ba48acae30fecd60928f5791188b80a9d6ee3840507ffda29fecd37b71/yarl-1.24.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f5f0cbb112838a4a293985b6ed73948a547dadcc1ba6d2089938e7abdedceef8", size = 111030, upload-time = "2026-05-19T21:29:00.148Z" },
+    { url = "https://files.pythonhosted.org/packages/82/5a/6f4cd081e5f4934d2ae3a8ef4abe3afacc010d26f0035ee91b35cd7d7c37/yarl-1.24.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5ec8356b8a6afcf81fc7aeeef13b1ff7a49dec00f313394bbb9e83830d32ccd7", size = 110392, upload-time = "2026-05-19T21:29:02.155Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/da/323a01c349bd5fb01bb6652e314d9bb218cee630a736bdb810ad50e4013f/yarl-1.24.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e7ebcdef69dec6c6451e616f32b622a6d4a2e92b445c992f7c8e5274a6bbc4c", size = 105612, upload-time = "2026-05-19T21:29:04.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/80/264ab684f181e1a876389374519ff05d10248725535ae2ac4e8ac4e563d6/yarl-1.24.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:47a55d6cf6db2f401017a9e96e5288844e5051911fb4e0c8311a3980f5e59a7d", size = 104487, upload-time = "2026-05-19T21:29:06.491Z" },
+    { url = "https://files.pythonhosted.org/packages/41/07/efabe5df87e96d7ad5959760b888344be48cd6884db127b407c6b5503adc/yarl-1.24.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3065657c80a2321225e804048597ad55658a7e76b32d6f5ee4074d04c50401db", size = 102333, upload-time = "2026-05-19T21:29:08.267Z" },
+    { url = "https://files.pythonhosted.org/packages/44/0c/bcf7c42603e1009295f586d8890f2ba032c8b53310e815adf0a202c73d9f/yarl-1.24.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:cb84b80d88e19ede158619b80813968713d8d008b0e2497a576e6a0557d50712", size = 99025, upload-time = "2026-05-19T21:29:10.682Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/82/84482ab1a57a0f21a08afe6a7004c61d741f8f2ecc3b05c321577c612164/yarl-1.24.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:990de4f680b1c217e77ff0d6aa0029f9eb79889c11fb3e9a3942c7eba29c1996", size = 110507, upload-time = "2026-05-19T21:29:12.954Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/8d/a546ba1dfe1b0f290e05fef145cd07614c0f15df1a707195e512d1e39d1d/yarl-1.24.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:abb8ec0323b80161e3802da3150ef660b41d0e9be2048b76a363d93eee992c2b", size = 103719, upload-time = "2026-05-19T21:29:14.893Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/b6/267f2a09213138473adfce6b8a6e17791d7fee70bd4d9003218e4dec58b0/yarl-1.24.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:e7977781f83638a4c73e0f88425563d70173e0dfd90ac006a45c65036293ee3c", size = 110438, upload-time = "2026-05-19T21:29:16.485Z" },
+    { url = "https://files.pythonhosted.org/packages/48/2d/1c8d89c7c5f9cad9fb2902445d94e2ab1d7aa35de029afbb8ae95c42d00f/yarl-1.24.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e30dd55825dc554ec5b66a94953b8eda8745926514c5089dfcacecb9c99b5bd1", size = 105719, upload-time = "2026-05-19T21:29:18.367Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/25/722e3b93bd687009afb2d59a35e13d30ddd8f80571445bb0c4e4ce26ec66/yarl-1.24.2-cp312-cp312-win_amd64.whl", hash = "sha256:7dafe10c12ddd4d120d528c4b5599c953bd7b12845347d507b95451195bb6cad", size = 92901, upload-time = "2026-05-19T21:29:20.014Z" },
+    { url = "https://files.pythonhosted.org/packages/39/47/4486ccfb674c04854a1ef8aa77868b6a6f765feaf69633409d7ca4f02cb8/yarl-1.24.2-cp312-cp312-win_arm64.whl", hash = "sha256:044a09d8401fcf8681977faef6d286b8ade1e2d2e9dceda175d1cfa5ca496f30", size = 87229, upload-time = "2026-05-19T21:29:22.1Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/4d/4b880086bd0d3e034d25647be1d830afc3e3f610e98c4ab3490af6b1b6d5/yarl-1.24.2-py3-none-any.whl", hash = "sha256:2783d9226db8797636cd6896e4de81feed252d1db72265686c9558d97a4d94b9", size = 53576, upload-time = "2026-05-19T21:31:03.909Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "4.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b9/d8/eab98a517c14134c0b2eb4e2387bc5f457334293ec5d2dd3857ec2966802/zipp-4.1.0.tar.gz", hash = "sha256:4cb57381f544315db7688e976e922a2b18cdb513d21cc194eb42232ba2a3e602", size = 26214, upload-time = "2026-05-18T20:08:57.967Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/13/547360d81e6d88d58492968ffda9f9542854f11310ee556fef14260cc886/zipp-4.1.0-py3-none-any.whl", hash = "sha256:25ad4e16390cd314347dd8f1de67a2ac538ae658ed4ab9db16029c07c188e97f", size = 10238, upload-time = "2026-05-18T20:08:57.045Z" },
+]