diff --git a/.gitattributes b/.gitattributes
index a6344aac8c09253b3b630fb776ae94478aa0275b..69019d5e7f95da0b93350a06377b14bad3b25dea 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -33,3 +33,5 @@ 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
+docs/evidence/libqi35metal.dylib filter=lfs diff=lfs merge=lfs -text
+docs/evidence/qi35_model filter=lfs diff=lfs merge=lfs -text
diff --git a/config/qi35-calibration-prompts-v1.json b/config/qi35-calibration-prompts-v1.json
new file mode 100644
index 0000000000000000000000000000000000000000..ddcd65195f9302acd958fee9d7132da9be718606
--- /dev/null
+++ b/config/qi35-calibration-prompts-v1.json
@@ -0,0 +1,66 @@
+{
+  "schema": "misaka.qi35.calibration-corpus.v1",
+  "tokenizer_sha256": "87a7830d63fcf43bf241c3c5242e96e62dd3fdc29224ca26fed8ea333db72de4",
+  "prompts": [
+    {
+      "name": "hello_world",
+      "text": "Hello, world",
+      "ids": [9419, 11, 1814]
+    },
+    {
+      "name": "paris",
+      "text": "The capital of France is",
+      "ids": [760, 6511, 314, 9338, 369]
+    },
+    {
+      "name": "arithmetic",
+      "text": "2 + 2 =",
+      "ids": [17, 478, 220, 17, 283]
+    },
+    {
+      "name": "freezing",
+      "text": "Water freezes at",
+      "ids": [27336, 90162, 506]
+    },
+    {
+      "name": "python_comprehension",
+      "text": "In Python, a list comprehension",
+      "ids": [623, 12654, 11, 264, 1103, 59036]
+    },
+    {
+      "name": "japanese_capital",
+      "text": "\u65e5\u672c\u306e\u9996\u90fd\u306f",
+      "ids": [161607, 110161, 14876]
+    },
+    {
+      "name": "quick_fox",
+      "text": "The quick brown fox",
+      "ids": [760, 3841, 13477, 37550]
+    },
+    {
+      "name": "gravity",
+      "text": "Explain gravity in one sentence:",
+      "ids": [814, 20139, 22525, 303, 799, 11316, 25]
+    },
+    {
+      "name": "rust_ownership",
+      "text": "Rust ownership prevents",
+      "ids": [49, 575, 14834, 27028]
+    },
+    {
+      "name": "logic_cat",
+      "text": "If all cats are mammals and Luna is a cat, then Luna is",
+      "ids": [2592, 660, 18833, 513, 53702, 321, 48130, 369, 264, 7993, 11, 1179, 48130, 369]
+    },
+    {
+      "name": "fibonacci",
+      "text": "def fibonacci(n):",
+      "ids": [727, 73111, 1393, 1590]
+    },
+    {
+      "name": "french_translation",
+      "text": "Translate good morning to French:",
+      "ids": [26583, 1603, 6353, 310, 8323, 25]
+    }
+  ]
+}
diff --git a/docs/adr-receipt-v3-node-ownership.md b/docs/adr-receipt-v3-node-ownership.md
new file mode 100644
index 0000000000000000000000000000000000000000..c79f6b8be468b7af978489e0df7f725d2a3ef5fe
--- /dev/null
+++ b/docs/adr-receipt-v3-node-ownership.md
@@ -0,0 +1,109 @@
+# ADR — Receipt v3 統合: 規約所有権の凍結と一括破壊変更(node ↔ runtime)
+
+**日付**: 2026-07-20  **状態**: Accepted(node 側設計者と合意)  **適用**: runtime-palw の次期一括変更
+**背景**: 最近の設計決定(PQ-only・Hash64・単一プール・supersession)は全て **node 側**に住んでおり、
+runtime の現行レシート(final-v7 系)は「Q4_K_M 較正期の使い捨て」と割り切り済み。互換 shim なしの
+**クリーンブレイク**で node 規約へ寄せる。「写した瞬間に不整合が固定される」を防ぐため、**写す前に**本
+所有権表を凍結する。
+
+---
+
+## 0. 所有権表(凍結)
+
+| 規約 | 原本 | 帰結 |
+|---|---|---|
+| 署名方式・鍵体系 | **node**(ML-DSA-87 のみ) | runtime の Ed25519 経路は排除 |
+| ハッシュ関数・幅・keying | **node**(keyed BLAKE2b-512 / Hash64) | 合意が再計算する全値が対象 |
+| 射影・match 述語 | **node**(§8 exact-match 集合) | `runtime_class_id` は非合意 telemetry |
+| 署名コンテキスト台帳 | **node** の `signature_domains.rs` | Receipt v3 の active context を core const と alignment test で固定 |
+| Receipt v3 hash-domain / wire / 正準直列化 | **node** の `mil/palw/src/receipt_v3.rs` | fixed-width・宣言順・LE。runtime は golden vector へ byte 一致させる |
+| 実行内容(trace 語彙・各 root の生成規則) | **runtime** | node 所有の Receipt v3 field へ格納し、署名対象 wire は変更しない |
+
+**所有権の一本化が肝** — 署名コンテキスト registry と Receipt v3 の byte-hash domain 定数は用途が
+異なるためファイルは分かれるが、どちらも node が原本であり runtime は独自 wire 規約を持たない。
+Receipt v3 context `misaka-palw-v3/receipt/mldsa87` は既に active registry 行であり、PENDING ではない。
+runtime-local の trace/root domain は実行内容の内部規則として残るが、最終値は node-owned field へ入る。
+
+## 1. 衝突 1(署名)— ML-DSA-87、鍵は credential、Ed25519 は「証明可能に不在」へ
+
+- consensus 経路(mint に効く receipt / leaf / vote)の署名は **すべて ML-DSA-87**。
+- **署名鍵 = 登録 credential 鍵** を v1 とする。delegation(credential が署名したセッション鍵)は運用
+  要求が出てから。導入する場合もセッション鍵は 87 のまま(パラメタセットを 2 つにしない)。
+- runtime の Ed25519 は EVM の secp256k1 と同じ手筋: **feature-gate で「provably-Ed25519-free な
+  mint 経路バイナリ」**にする(悪い状態を表現不能に)。
+- 既存 final-v7 系レシートは**移行せず破棄**(較正期の使い捨て、既定方針どおり)。
+
+## 2. 衝突 2(ハッシュ)— Hash64 keyed BLAKE2b-512 を全面採用
+
+- 判定基準: 「**合意側の誰かが再計算する値か**」。該当: `output_commitment`、checkpoint/execution root、
+  route root、state root、schedule commitment — 端から端まで同一関数でなければ再計算照合が成立しない。
+- Receipt v3 の projection/body/id/nullifier/output/pair は、node が定義する 6 個の byte-domain と
+  fixed-width・宣言順・LE preimage を使う。可変長 field の汎用 framing を Receipt v3 wire へ流用しない。
+- runtime-local root の内部 domain は別管理とし、その出力を node-owned Receipt v3 field へ格納する。
+- runtime 現行の Hash32 / SHA3 系列 domain-hash はすべて対象(receipt フィールド型は Hash32→**Hash64**)。
+- BLAKE3 は **S0 実測で BLAKE2b が受領税目標(<1%)を割ると判明した場合にのみ**、宣言行付きの第二ハッシュ
+  として検討。既定は一本。
+
+## 3. 衝突 3(射影)— MatchProjectionV2 として作り直す
+
+- V1 の `runtime_class_id` 一致要件をコピーすると「**異機種が bit 一致しても永久に mint されない**」=
+  単一プール化(canonical-integer トラックの成果)の否定になる。
+- 対応は原子性規則の runtime 側適用: **射影の再定義と diversity 述語の削除を同一統合で**。
+- V2 の中身 = §8 exact-match 集合:
+  `compute_set_id / job_challenge / output_commitment / schedule root / execution root / route root /
+  state root / CU / token count / stop reason`
+- `runtime_class_id` は **ImplementationTelemetry**(非合意)へ移動。
+- **V1 の名前を再利用しない**(「名前だけ同じで中身をすり替えると未来の実装者が泣く」)。V2 として切る。
+
+> 整合メモ: これは本リポジトリの canonical-integer 実証(実 attention/層が CPU×2 ISA + CUDA でバイト一致、
+> [4b-2b](evidence/canonical-int-attention-4b2b-2026-07-19.md) / [4b-3](evidence/canonical-int-fulllayer-4b3-2026-07-20.md))
+> と噛み合う: 異ベンダ bit 一致を mint 可能にするのは V2 射影があってこそ。
+
+## 4. Receipt v3 — 一括破壊変更(破壊は 1 回)
+
+上 3 点は個別に入れず、予約済みの一括バンドルに吸収:
+**ML-DSA envelope / Hash64 / leaf フィールド(compute_set_id・job_challenge・checkpoint root・state root・
+stop reason 等)/ challenge 束縛 / checkpoint root**。
+
+**runtime 側の実施順(完了済み)**:
+1. node Receipt v3 の署名 context と 6 byte-hash domain を原本として固定
+2. canonical body/projection を fixed-width・宣言順・LE、Hash64 keyed BLAKE2b-512 へ移行
+3. ML-DSA-87 化(Ed25519 を v3 経路で表現不能にする)
+4. MatchProjectionV2(+ `runtime_class_id` → ImplementationTelemetry)
+5. production encoder/worker/verifier を node golden と byte 一致させ、admission expectations を必須化
+
+## 5. 経済側の付記(node 側で対応、runtime は観測のみ)
+
+- `pump_ev_negative`: esc(k) は credential 単位のため**回転 sybil カルテル**(min-bond credential 多数で
+  no-show を分散、全イベント k=0)が esc をほぼ回避 → コストは平坦モデルに退化し pump が黒字化し得る
+  (140k < 167k)。よって真の目標状態は「**平坦モデル単独で EV 負**」、esc は defense-in-depth に降格。
+  P₀ 再較正(1.3–1.5×+余裕)で到達可能。薄市場は N_STAT hold が π ごと凍結するので pump 不能。
+- テスト pin は再較正完了と同時に `flat_cost < gain` → `flat_cost > gain` へ反転。
+- `NoShowPenaltyDestination` に `ToRequester` を**設けない**型表現は維持(悪い状態を表現不能に)。
+
+## 帰結(runtime-palw への具体的影響リスト)
+
+- `receipt.rs` / `protocol_v2.rs`: ComputeReceipt **v3**(Hash64 フィールド、新 leaf フィールド)。
+  Ed25519 envelope は feature `legacy-ed25519`(既定 OFF)。v1/v2 デコードは検証ツール専用に隔離。
+- 全 domain-hash site(schedule chain / trace roots / nullifiers / commitments): keyed BLAKE2b-512 へ。
+  タグは node 台帳の行として登録し、runtime 内のタグ定数は台帳から生成 or 参照に一本化。
+- `matcher.rs`: `MatchProjectionV2`(§8 集合)。`runtime_class_id` は `ImplementationTelemetry` 構造体へ。
+- `mint.rs`: 署名方式ゲート(ML-DSA でないものは mint 経路で不適格)を追加。
+- receipts/final-v7 は破棄対象(アーカイブとしてのみ保持、照合対象にしない)。
+- [palw-node-integration-spec.md](palw-node-integration-spec.md) は本 ADR を上位とし、v1/Ed25519/V1 射影の
+  記述は「現行(較正期)実装の記録」に降格(同文書冒頭に supersession banner)。
+
+## 実装状況(2026-07-20 更新)
+
+- **node 原本実装済み**: `MISAKA.../mil/palw/src/receipt_v3.rs` が `ComputeReceiptV3` / projection /
+  output/nullifier/pair の fixed-width LE bytes と byte-domain、selected-chain expectations 付き検証を所有する。
+  fixture は `mil/palw/test-data/receipt_v3_golden_v1.json`。
+- **runtime production 経路を整合済み**: `runtime-palw/src/receipt_v3.rs` と integer/testnet worker CLI は
+  node と同じ canonical bytes、Hash64、credential binding、execution nullifier、output commitment、
+  ML-DSA-87 context `misaka-palw-v3/receipt/mldsa87`(vk 2592B / sig 4627B)を使用する。node fixture の
+  body/digest/pair-id golden と一致し、selected-chain admission API は network/compute-set/challenge/slot/
+  epoch/registered credential の `ReceiptV3Expectations` を必須とする。self-consistency と low-level matcher は
+  admission verdict ではない。
+- **残り(ネットワーク統合)**: submission transport/scheduler、node genesis network identity と job challenge、
+  provider credential registry 接続、global nullifier/lifecycle、receipt DA と監査・決済。暗号 backend の
+  「次段配線」ではなく、これら外部ライフサイクルが公開・有価値 network の blocker である。
diff --git a/docs/canonical-integer-compute-design.md b/docs/canonical-integer-compute-design.md
new file mode 100644
index 0000000000000000000000000000000000000000..411c81ad0903773dbaabcf7365d8db0e95c44541
--- /dev/null
+++ b/docs/canonical-integer-compute-design.md
@@ -0,0 +1,188 @@
+# Canonical Integer Compute — 決定性クラス統合の設計（RTX20/40 を 1 クラスに）
+
+**日付**: 2026-07-19  **目的**: 異なる GPU 世代（RTX 20 `sm_75` / RTX 40 `sm_89`）・異なるベンダを、**1 つの
+determinism / pool クラス**に統合する。**手段**: 浮動小数点をやめ、**整数（固定小数点）で計算**し、`int32`
+累積の結合律を使って hardware 非依存のビット同一性を「祈り」ではなく **設計上の性質**として保証する。
+
+> 本設計は [spec-snapshot §6.1（QW36-int）](spec-snapshot-qwen36-2026-07-19.md) の「整数意味論」章を、
+> クラス統合という目的から具体化したもの。**現状は未実装**（設計 + 基礎 primitive の実機実証まで）。
+
+---
+
+## 0. 結論（先に）
+
+- fp のままでは RTX20/40 を同一クラスにできる保証はない。実測でも candle 0.9.2→0.11 の bump だけで
+  **Ada の token commitment が flip**（`f151cd16…`→`60a662e2…`）した — 低マージンの決定手が存在し、kernel
+  差で argmax が動く（[COMMITMENTS 参照](../README.md)）。Metal は偶然保持しただけ。
+- **整数化すれば、順序・kernel・世代・ベンダに依らずビット同一**になる。`int32` 加算は 2³² を法とする
+  可換環で、wrapping 込みで結合律・交換律が厳密に成立するため、reduction 順序を固定する必要すらない。
+- 本セッションで基礎 primitive を実装し、**Apple aarch64 と NVIDIA host x86_64 で canonical 整数出力が
+  バイト同一**（commitment `743652581b0b9725`）、fp は順序で割れることを実機確認した（§4）。
+- 追い風: **int8 tensor core は Turing(`sm_75`)/Ampere/Ada/Hopper に共通**（bf16 と違い Turing にもある）
+  ので、整数パスなら RTX20〜40+ を 1 クラスに束ねられる筋がある。
+
+---
+
+## 1. なぜ fp では世代を跨げないか
+
+- **根本原因**: IEEE-754 加算は**非結合** `(a+b)+c ≠ a+(b+c)`。GPU の matmul は tensor core の MMA、warp
+  reduction、タイル分割で**加算順序がカーネル/世代ごとに異なる** → 丸めが変わる → ビットが変わる。
+- **実測の裏付け（本リポジトリ）**: candle を 0.9.2→0.11 に上げただけで、**同じ Ada カード**上で CUDA の
+  token `vector_commitment` が変化した。これは job set 内に「top-1 マージンが極小の決定手」が存在する
+  直接証拠。世代違い（Turing vs Ada、tensor core 世代が違う）ではさらに割れやすい。
+- argmax 自体は頑健（Apple M1 Max と M4 Pro は logits が違っても token 一致）。しかし**低マージン手が
+  1 つでもあれば**、その手で世代差が argmax を反転させ、token 列全体のバイト一致が壊れる。
+
+---
+
+## 2. 核心定理 — 整数累積は hardware 非依存
+
+**定理.** `int32` 上の加算は、二の補数 wrapping を含めて結合的かつ可換（2³² を法とする可換環）。
+したがって `int8 × int8 → int32` GEMM の各出力要素は、**k 方向の reduction 順序に依らず同一ビット**。
+
+**系.** 同じ量子化入力を与えれば、逐次和・ペアワイズ木・SIMD レーン・GPU warp-shuffle・マルチタイル、
+どの実装でも、CPU / Apple GPU / NVIDIA(Turing/Ampere/Ada/Hopper) のどれでも**同一ビット**を出す。
+fp と違い、順序を仕様で固定する必要すらない（整数であること自体が不変性を与える）。
+
+---
+
+## 3. Canonical 整数計算パスの仕様（QW36-int）
+
+肝は「**どこにも fp を混入させない**」こと。各段を整数関数として一意に定義する。
+
+### 3.1 量子化
+- **重み**: W4（or W8）対称量子化。スケールを `(multiplier: i32, shift: u32)` の固定小数点で pin。
+  丸めは round-half-to-even 固定。決定論的で 1 回だけ（GGUF に相当）。
+- **活性**: A8 対称。per-tensor（or per-token）スケールを固定小数点で。**量子化の除算も固定小数点**
+  （`x * inv_scale_M0 >> shift`）で行い fp を使わない。
+
+### 3.2 GEMM
+- `int8 × int8 → int32` 累積。tensor core 使用可（§5 caveat）。順序自由（結合律）。
+
+### 3.3 再量子化 `int32 → int8`（**最重要・fp 再混入の最大リスク**）
+- gemmlowp / TFLite 形式: `q = clamp((acc * M0 + (1<<(shift-1))) >> shift, -127, 127)`。
+  `M0: i32`, `shift: u32` を層ごとに pin。**整数のみ・丸め点固定**。ここで fp を使うと台無しになる。
+
+### 3.4 非線形
+- softmax / SiLU / sigmoid / exp / GELU は**固定小数点 or LUT**（量子化ドメイン上のテーブル）で定義し、
+  入力→出力を整数関数として一意化。
+- RMSNorm / LayerNorm は平方根を含む → 固定小数点 `rsqrt`（Newton 反復回数を固定）or LUT。
+
+### 3.5 routing / argmax / sampler
+- MoE router logits は整数 → **top-k は整数比較**、同点は低 index 優先で決定的。
+- 最終 argmax も整数比較 + 決定的 tie-break。greedy は完全決定的で、これが token `vector_commitment`
+  を backend 非依存にする。
+
+### 3.6 DeltaNet（hybrid model のみ）
+- 状態更新を**トークン単位で再量子化**（[spec-snapshot §6.1(2)](spec-snapshot-qwen36-2026-07-19.md)）。
+  丸め点を固定し、逐次デコードとチャンク並列 prefill が同一の丸め列を辿るようにする。
+
+---
+
+## 4. 実証（本セッション・実機）
+
+- prototype: `docs/evidence/canon_int.rs`（依存なし、`rustc -O canon_int.rs && ./canon_int`）。
+- `int8×int8→int32` GEMM を **逐次和と木和の 2 つの reduction 順序**で計算し比較、加えて同じソースを
+  2 ISA で実行。結果（[evidence md](evidence/canonical-int-cross-isa-2026-07-19.md)）:
+
+| machine | ISA | INT 順序不変 (seq vs tree) | fp32 順序不変 | canonical commitment |
+|---|---|---|---|---|
+| Mac (Apple) | aarch64 | **MATCH** | DIFFER | `743652581b0b9725` |
+| RTX box (NVIDIA host) | x86_64 | **MATCH** | DIFFER | `743652581b0b9725` ✅ 同一 |
+
+- 読み取り: **整数 → 順序にも ISA にも非依存**（同一ビット）。**fp → 順序で割れる**（`9019ee04…` vs
+  `e68f80da…`）= GPU の kernel 差がそのままビット差になる、という世代跨ぎ不能の正体。
+
+**increment 2（GPU、完了）**: 同じ int8 GEMM を **custom GPU kernel** で実装し実 GPU 2 ベンダで実行
+（[GPU evidence](evidence/canonical-int-gpu-3backend-2026-07-19.md)、`canon_metal.swift` / `canon_cuda.cu`）:
+
+| backend | hardware | ISA / arch | INT fnv |
+|---|---|---|---|
+| CPU | Apple M1 Max | aarch64 | `4b138ed70d137781` |
+| CPU | NVIDIA/WSL2 host | x86_64 | `4b138ed70d137781` |
+| **Apple Metal GPU** | Apple M1 Max | Apple GPU | `4b138ed70d137781` |
+| **NVIDIA CUDA GPU** | RTX 4060 Ti | Ada `sm_89` | `4b138ed70d137781` |
+
+→ **Apple GPU ≡ NVIDIA Ada ≡ x86 CPU ≡ ARM CPU** が同一ビット。canonical 整数 GEMM は vendor・microarch・
+ISA 非依存であることを実 GPU 上で実証。fp では candle bump だけで Ada の commitment が動いたのと対照的。
+残る Turing（`sm_75`）実機確認は増分 6（HW 未所持）。
+
+---
+
+## 5. これで RTX20/40 が 1 クラスになる理由 と caveat
+
+**なる理由**
+- int8 tensor core は **Turing(`sm_75`)/Ampere/Ada/Hopper 共通**。bf16 が Turing に無い問題（
+  [docs/cuda-turing の背景](../README.md)）を回避し、全世代で**同じ整数演算**を実行できる。
+- MMA int8 命令の内部累積は決定的。タイル間の `int32` 累積は結合律で順序不問 → **kernel/世代差を吸収**。
+
+**caveat（正直に）**
+1. 量子化・再量子化・非線形を**全 backend で同一定義**にすること。ここに fp が 1 箇所でも混ざると不変性は
+   壊れる（§3.3 が最大リスク）。
+2. MMA の入力レイアウト・飽和/オーバーフロー挙動が仕様通りか、**各 backend で実測検証**が要る。
+3. 前提は「同じ量子化モデル」。量子化そのものが決定論的でなければ出発点で割れる。
+4. **Turing 実機は未所持** → 最終的な RTX20 でのビット一致確認はユーザ側 HW ステップ。
+
+---
+
+## 6. 実装ロードマップ（increment）
+
+- **increment 1（完了）**: 定理 + prototype + cross-ISA CPU 実証（§4）。
+- **increment 2（完了）**: GPU int8 canonical GEMM kernel（Metal shader + CUDA `.cu`）を実装し、CPU / Apple
+  Metal / NVIDIA CUDA(Ada) の 4 経路でビット一致（`4b138ed70d137781`）を実機実証（§4）。※ candle 0.11 の
+  公開 Tensor API は int8×int8→int32 の GPU matmul を持たないため custom kernel を書いた。次の硬化は
+  tensor-core / split-K 版で GPU 並列 reduction を直接検証すること。
+- **increment 3（完了）**: 1 layer（int8 linear + int32 bias + 固定小数点 requant + 整数 LUT 非線形）を
+  canonical 化し、CPU aarch64 / CPU x86_64 / Apple Metal / NVIDIA CUDA(Ada) の 4 経路で LAYER fnv
+  `440bd1b93d991fe0` に一致（[evidence](evidence/canonical-int-layer-4backend-2026-07-19.md)、
+  `canon_layer.{rs,swift,cu}`）。requant は整数 mul+shift、非線形は pinned 整数 LUT lookup — **fp 再混入の
+  2 大リスク（requant の fp 除算・on-device transcendental）を両方排除**。q は `[-127,127]` 全域に分布
+  （非退化）。
+- **increment 4a（完了）**: 残る op 型を canonical 整数化 — softmax（固定小数点 exp、整数 Horner 生成の
+  pinned テーブル）/ RMSNorm（整数 rsqrt = 整数 Newton の isqrt）/ argmax — を CPU aarch64 / CPU x86_64 /
+  Apple Metal / NVIDIA CUDA(Ada) で COMBINED fnv `4bf581ead4d57139` に一致
+  （[evidence](evidence/canonical-int-ops-4backend-2026-07-19.md)、`canon_ops.{rs,swift,cu}`）。
+  **inc2(GEMM)+inc3(bias/requant/LUT)+inc4a(softmax/RMSNorm/argmax)= dense transformer forward に要る
+  全 op 型が backend 非依存**。
+- **increment 4b**: 上記 primitive を dense Qwen2.5-0.5B の **実重み forward**（24 層 / RoPE / GQA /
+  SwiGLU / tied LM head）に組み上げ、verifier に `canonical` クラスを追加し、token `vector_commitment` が
+  CPU/Metal/CUDA で同一になることを実証。量子化の品質保持も含む大きな統合。
+- **increment 5**: 本番 hybrid Qwen3.6（MoE + DeltaNet）へ。[spec-snapshot §6.1](spec-snapshot-qwen36-2026-07-19.md)
+  の整数意味論を実装。
+- **increment 6**: 実機 Turing（RTX 2060 等）で increment 4 の値一致を確認 → **RTX20/16 系を Ada と同一
+  クラスに登録**。
+
+---
+
+## 7. 正直な限界
+
+- 本セッションは **CPU 整数の cross-ISA 実証**まで。GPU int8 kernel のビット一致は未実証（increment 2）。
+- Turing 実機未所持 → 最終確認はユーザ HW ステップ。
+- candle デモ verifier は fp で動くので、canonical class は**別実装（runtime 側）**になる。
+- 性能/精度トレードオフ: 整数パスは精度検証が要る。int8 tensor core は速いが、量子化誤差が argmax を
+  変えないか（perplexity・token 一致率）を実測で確認する必要がある。
+
+---
+
+## 8. Metal 移植のための i128→i64 refactor 設計(2026-07-20 追記)
+
+MSL には 128-bit 整数が無い(`long`=i64 まで)。hifi 構成は Q60 スケールで i128 積(最大 ~2^102)を
+使うため、そのままでは Metal に載らない。設計:
+
+1. **スケールを正規化 (m0, e) 表現に**: `scale = m0 × 2^e`、`m0 ∈ [2^30, 2^31)`(31-bit 正規化)。
+   すべてのスケール演算後に renormalize(shift+指数調整)。
+   - `mul(s1, s2)`: `m0 = (m0a×m0b) >> 31`(積は < 2^62 → **i64 に収まる**)、`e = ea+eb+31`、renorm。
+   - `ratio = s1/s2`: `m0 = (m0a << 31) / m0b`(分子 < 2^62)、`e = ea−eb−31`、renorm。
+2. **apply(value, scale)** = `value × m0 × 2^e`: `value`(≤2^42)× `m0`(2^31)= ~2^73 — i64 超。
+   → **mulhi ベースの 64×64→128 エミュレーション**: MSL の `metal::mulhi(long, long)` + `x*y`(下位)で
+   128-bit 積を 2 word で構成し、`>> (−e)` を 2-word shift で実施(丸めは下位 word から桁上げ)。
+   固定パターンなので ~15 行のヘルパで済む。
+3. **残る 128/64 除算は 2 箇所だけ**: (a) A·V の `acc·2^SC / den` — `acc ≤ 2^42`、`den ≤ 2^20` 程度なので
+   先に `acc / den`(i64 除算)と剰余補正で分解可能(丸め規約を参照実装と厳密一致させること)。
+   (b) 残差の `(colsq << SC)/xsq` — 正規化表現では ratio 演算(上記 1)に置換され消える。
+4. **検証手順**: まず Rust で「正規化 (m0,e) + mulhi エミュ」版を書き、既存 i128 版と**同一 fingerprint**
+   (`906729150a5a926a` / full-model FNV `65d2e3adaf2dce9e`)を出すことを確認 → その Rust 版を MSL に
+   直訳(意味論が i64+mulhi に閉じているので直訳可能)→ M1 Max で layer → full-model の順に一致確認。
+
+状態: **設計確定・実装は未着手**(このセッションでは CPU×2 ISA + CUDA の 4 実装一致を優先)。
+Apple ハードは CPU(aarch64)で full-model 一致済みのため、残るのは Apple **GPU** 固有分のみ。
diff --git a/docs/canonical-integer-inc4b-fullmodel-design.md b/docs/canonical-integer-inc4b-fullmodel-design.md
new file mode 100644
index 0000000000000000000000000000000000000000..5d3c468a762db5d4d806779e67ae308a37c87b0f
--- /dev/null
+++ b/docs/canonical-integer-inc4b-fullmodel-design.md
@@ -0,0 +1,114 @@
+# inc4b 設計 — dense Qwen2.5-0.5B の canonical 整数 forward
+
+**日付**: 2026-07-19  **前提**: [canonical-integer-compute-design.md](canonical-integer-compute-design.md)
+の increment 4b。inc2–4a で **全 op 型の backend 非依存を実機実証済み**（GEMM / bias / requant / LUT /
+softmax / RMSNorm / argmax）。本書はそれらを **実重みの Qwen2.5-0.5B forward** に組み上げ、verifier で
+token `vector_commitment` を CPU/Metal/CUDA 同一にするための設計。
+
+## 0. 目的
+
+- 実モデルの forward 全体を **fp を一切使わず整数**で通し、**backend 非依存の token commitment** を出す。
+- これが完成すると Apple/Metal・NVIDIA/CUDA・AMD/ROCm・CPU が **1 pool** で相互検証でき、「Mac の job を
+  CUDA で丸ごと検証」がモデル全体で成立する。
+
+## 1. 対象アーキ（`/root/models/qwen0.5b-q4.gguf` GGUF 実測）
+
+| 項目 | 値 |
+|---|---|
+| architecture | `qwen2`（Qwen2.5-0.5B-Instruct） |
+| block_count（層） | 24 |
+| embedding_length（hidden d） | 896 |
+| feed_forward_length（FFN） | 4864（SwiGLU: gate/up 896→4864, down 4864→896） |
+| head_count / head_count_kv | 14 / 2（GQA, group=7）, head_dim=64 |
+| rope.freq_base | 1000000.0 |
+| rms_norm_eps | ~1e-6 |
+| file_type | 15（Q4_K_M） |
+| vocab | 151936（tied: `output` = `token_embd`）※ token_embd tensor shape で確認 |
+| bias | Qwen2 は q/k/v proj に **bias 有**、o_proj は bias 無 ※ tensor 名で確認 |
+
+## 2. 量子化方式の決定 — **W8A16**（4b-2a 実測後の改訂）
+
+> **改訂（[4b-2a evidence](evidence/canonical-int-attention-4b2a-2026-07-19.md)）**: 実測で W8A8（int8 活性）は
+> attention の**活性外れ値**で誤差 ~21% と大きく、素の SmoothQuant(α=0.5)では改善せず(要 calibration 調整)。
+> **W8A16(int8 重み × int16 活性 → int64 累積)**なら外れ値を潰さず、RMSNorm を高精度化(下記)した上で
+> **attention 誤差 2.6%** に収まる。int8×int16 は tensor core 非対応(通常 ALU、決定性は不変)なので、
+> tensor core を使う W8A8+調整済み SmoothQuant は後段の性能最適化に回す。**まず W8A16 で正確な canonical を作る。**
+> また RMSNorm の整数実装は「正規化値を高精度固定小数点(例 Q20)で保持」すること必須(`>>` で潰すと精度崩壊。
+> これが 4b-2a で 36% 誤差の真因だった)。
+
+### 旧 §2（W8A8 前提、tensor core 最優先版 — 参考）
+
+- **重み int8・活性 int8・累積 int32**。理由: (1) int8 tensor core は Turing〜Hopper 共通で世代統合に最適、
+  (2) 0.5B が W8A8 で ~0.5GB と軽い、(3) 4bit より精度余裕があり最初の正しさ確認向き。W4A8（~0.25GB）は
+  サイズ最適化として後続。
+- **重み量子化はオフラインで 1 回**（bf16 原重み → per-output-channel 対称 int8、scale は
+  `(multiplier:i32, shift:u32)` の固定小数点で pin）。**fp はこのオフライン工程のみで、runtime には一切
+  入らない**。scale は成果物（`.canon` ファイル）に焼き込む。Q4_K_M の fp16 block scale は使わず、bf16
+  原重みから再量子化する（Q4_K_M は既に lossy かつ fp scale なので canonical には不適）。
+- **活性量子化**: per-token 動的対称 int8。scale 計算は「max(|x|) を整数で求め、`127/max` を固定小数点
+  reciprocal」で行い fp を使わない（= inc3 の requant 機構の一般化）。または静的 calibration scale を pin。
+- **residual stream は int32（固定小数点）で保持**し、各 matmul の入口でだけ int8 に量子化する（層をまたぐ
+  ドリフトを防ぐ）。
+
+## 3. 各 op の整数仕様（すべて実証済み primitive の合成）
+
+| stage | 整数仕様 | 依拠 primitive |
+|---|---|---|
+| token embedding | int8 埋め込み表を gather（tied） | 決定的 gather |
+| RMSNorm | `Σx²`(int64)→ 整数 rsqrt(isqrt)→ γ(pin, 固定小数点) | **inc4a** |
+| Q/K/V proj (+bias) | int8 GEMM → +int32 bias → 固定小数点 requant | **inc2+inc3** |
+| RoPE | cos/sin を **位置×dim/2 の固定小数点 pinned テーブル**化（on-device で fp 三角関数を計算しない）→ 整数 mul-add 回転 | 新（LUT と同型、pin） |
+| QK^T | int8 GEMM（head 毎）→ int32 scores | **inc2** |
+| scale 1/√dₕ | 固定小数点定数の mul-shift | inc3 |
+| causal mask | masked 位置に大負整数を加算 | 整数 |
+| softmax | max 減算 → exp は pinned 固定小数点表 → int64 和 → 整数除算 | **inc4a** |
+| A·V | probs(Q16) × V(int8) 累積(int64) → requant | inc2+inc3 変種 |
+| o_proj + residual | int8 GEMM → int32 residual 加算 | inc2 |
+| SwiGLU FFN | gate/up = int8GEMM+requant；act = SiLU LUT(gate)；h = act·up → requant；down = int8GEMM+requant | **inc2+inc3** |
+| final RMSNorm | 同上 | inc4a |
+| LM head（tied） | int8 GEMM x × embedddingᵀ → int32 logits | inc2 |
+| argmax（greedy） | 整数比較・決定的 tie-break | **inc4a** |
+
+**RoPE テーブル**: 32768 pos × 32 dim-pair × (cos,sin) を固定小数点(例 Q15)で pin ≈ 8MB。必要位置のみ
+生成でも可だが、生成式は整数固定小数点で決定的にすること（fp `sin/cos` を on-device で使わない）。
+
+## 4. 決定論の担保
+
+全 stage が「inc2–4a で backend 一致を実証済みの整数 op」＋「pin された固定小数点テーブル（RoPE/LUT/scale）」
+＋「決定的 gather」の合成。**backend 一致な op の合成は backend 一致**（fp が 1 箇所も無い限り）。よって
+full forward は **構成上** backend 非依存。残るのは「実装で fp を混入させないこと」の徹底のみ。
+
+## 5. 精度検証計画（別軸: 決定論 ≠ 精度）
+
+- canonical 整数 forward と **fp 参照（candle）**を同一プロンプトで greedy 実行し、**token 一致率**と
+  **perplexity** を測る。W8A8 は多くの token で fp に一致するはずだが、低マージン token は分岐し得る
+  （それは fp とは別の、より低精度だが**決定的**なモデル、という理解）。
+- **重要**: canonical class の golden token commitment は fp class の値とは**別物**（新しいクラス）。価値は
+  「全 backend で同一」であること。品質が不足なら per-group scale / W8A16 活性へ。
+
+## 6. verifier 統合
+
+- `misaka-verify` に `--canonical`（整数 forward）モードを追加。`published.json` に **`canonical` クラス**
+  を 1 つ追加し、その token `vector_commitment` は **backend 非依存の単一値**（Apple+NVIDIA+AMD+CPU 共通）。
+- fp の per-vendor クラス（metal/cuda）はそのまま残し、canonical を並置（移行期）。
+
+## 7. 実装 sub-increments
+
+- **4b-1**: オフライン量子化器 — bf16 原重み → W8A8 `.canon` 成果物（pin: 重み int8 + per-channel 固定小数点
+  scale + RoPE/LUT テーブル + config）。
+- **4b-2**: attention ブロック 1 個（RoPE + GQA QK^T + scale + causal + softmax + A·V + o_proj）を整数実装、
+  4-backend 一致（inc4a の延長）。
+- **4b-3**: full transformer layer 1 個（attn + SwiGLU + 2×RMSNorm + residual）を整数実装、4-backend 一致。
+- **4b-4**: 24 層 + LM head + argmax の full forward、実プロンプトで token 列を出し 4-backend 一致。
+- **4b-5**: fp 参照との token 一致率/perplexity 測定、verifier に `canonical` クラス統合・golden 記録。
+
+## 8. リスクと正直な限界
+
+- **精度**: W8A8 が 0.5B の出力品質を落とす可能性 → 4b-5 で定量化。不足なら per-group/W8A16 に段階調整。
+- **residual 精度**: int32 固定小数点の bit 幅設計を誤るとドリフト → 4b-3 で検証。
+- **工数**: これは実質「整数推論エンジン 1 本」。単発カーネルの数倍で、複数セッション想定。
+- **Turing 実機**: 依然未所持。4b-4 の値は定理上 Turing でも一致するが確認は HW ステップ（inc6）。
+- **本番 hybrid（Qwen3.6 MoE+DeltaNet, inc5）**は 4b の後。MoE 整数 top-k・DeltaNet per-token 再量子化は
+  [spec-snapshot §6.1](spec-snapshot-qwen36-2026-07-19.md) 参照。
+- 本書の scale/表は demonstrator。**本番は正確な scale・表・反復回数を pin し、モデル成果物と consensus に
+  含める**必要がある。
diff --git a/docs/canonical-integer-qwen36-design.md b/docs/canonical-integer-qwen36-design.md
new file mode 100644
index 0000000000000000000000000000000000000000..afcb0396db2c926bb72671fae582b49ffbb86fcf
--- /dev/null
+++ b/docs/canonical-integer-qwen36-design.md
@@ -0,0 +1,181 @@
+# QI35 — Qwen3.6-35B-A3B canonical 整数 forward 設計(inc5 具体化)
+
+**日付**: 2026-07-20  **対象モデル**: `models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf`
+(23,938,321,728 bytes — 受領/receipt トラックが commit している本番 blob そのもの)
+**前提**: [canonical-integer-compute-design.md](canonical-integer-compute-design.md)(inc1–4b、0.5B hifi で
+fp 12/12 追跡 + 4 実装ビット一致を実機実証済み)。本書はロードマップ **increment 5**(本番 hybrid)の設計。
+**方針転換**(ユーザ指示 2026-07-20): 以後 Qwen3.6-35B のみを対象とし、0.5B デモは基盤実証としてのみ参照。
+
+---
+
+## 0. 結論(先に)
+
+1. **重み源は Q4_K_M blob そのもの**。bf16 再量子化はしない。Q4_K/Q6_K の fp16 スケール
+   (d, dmin)は**ビット操作だけで exact な整数×2^e に分解できる**ため、GEMM を「4/6-bit 整数 ×
+   A24 整数活性 × 整数スケール代数」として**一切の丸め追加なしに**定義できる(§4)。
+   → 変換成果物ゼロ、receipt が commit する blob hash がそのまま canonical 整数モデルの重み hash。
+2. **整数化により spec-snapshot §6.3 の最難関(DeltaNet の per-token 丸め列を chunked prefill が
+   再現する条件)は構造的に消滅**する。整数加算は結合的なので、GEMM をバッチしつつ状態再帰を
+   トークン順に回せば、逐次 decode と prefill は**自動的にビット一致**する(§7)。
+3. Mac Studio M1 Max 32GB は本モデルにとって**構造的に最良のローカル機**: 23.9GB blob が unified
+   memory に丸ごと載る(RTX 4060 Ti 16GB VRAM には載らない)。Metal offload(QI35-5)の速度目標は
+   fp Metal llama.cpp と同オーダーの tok/s。
+
+---
+
+## 1. アーキテクチャ ground truth(GGUF + vendored llama.cpp 実測)
+
+メタデータ(`docs/evidence/` の gguf_full_dump 実行結果、2026-07-20):
+
+| 項目 | 値 |
+|---|---|
+| arch / params | `qwen35moe` / 35,951,822,704 |
+| 層 | 40(`full_attention_interval=4`: **(i+1)%4==0 の層 3,7,…,39 が full attention(10 層)、他 30 層が gated delta net**。`qwen35moe.cpp:39` `is_recr_impl[i] = (i+1)%4 != 0`) |
+| d_model / vocab | 2048 / 248,320(eos 248046) |
+| attention | 16 head × head_dim 256、GQA kv 2 head(`head_count_kv` 配列)、q/k per-head RMSNorm、**Q 射影は query+gate 融合出力 8192**(interleave: head 毎 [q256, gate256])、kq_scale = 1/√256 = **1/16(有理数)**、出力は sigmoid(gate) で elementwise gating |
+| RoPE | IMROPE だが**テキスト入力では素の NEOX RoPE に退化**(3 位置成分が同値、`llama-graph.cpp:128-139`)。回転は先頭 64/256 次元のみ、ペア (i, i+32) i∈0..31、θ_k = pos·(10^7)^(−2k/64)。**YaRN 無効**(GGUF に rope.scaling 無し → ext_factor=0, freq_scale=1, attn_factor=1) |
+| DeltaNet | conv kernel 4 / k-head 16×128 / v-head 32×128(d_inner 4096)/ state 128×128×32head / `ssm_dt`[32] bias / `ssm_a`[32](= −exp(A_log) 変換済み F32)/ β,α 射影 [2048,32] / 出力 gate z [2048,4096] / per-head RMSNorm(ssm_norm[128])× SiLU(z) / ssm_out [4096,2048] |
+| MoE(全 40 層) | router `ffn_gate_inp` [2048,256] **F32**、**softmax→top-8**(argsort desc)、選択重みを和で正規化(fp は F16 min でクランプ)、expert_weights_scale **無し**(0.0 → スキップ確認)、expert FFN 512(gate/up Q4_K・down Q6_K、fused gate_up 無し)、shared expert 512 + sigmoid(gate_inp_shexp[2048,1] F16) |
+| head | `output.weight` Q6_K [2048,248320](**非 tied**)、output_norm RMSNorm |
+| 量子化型 | Q4_K 349 / Q6_K 94 / F32 544 / F16 207 tensor |
+| 同梱・非実行 | vision tower `v.*` 441 tensor、MTP `mtp.*` 20 tensor(nextn KV 無し → n_layer_nextn=0、テキスト経路は 40 trunk 層のみ。ローダは個数整合のみ処理 `qwen35moe.cpp:184-192`) |
+| その他 | `ssm.v_head_reordered=True` は**ランタイム未参照**(変換時に並べ替え済み、実測 grep 0 件) |
+
+fp 意味論の出典(全て vendored `llama.cpp`、行番号 2026-07-20 時点):
+- 層構造 / attention / MoE 呼び出し: `src/models/qwen35moe.cpp:202-599`
+- DeltaNet per-token 再帰(canonical の基準): fused op CPU 実装 `ggml/src/ggml-cpu/ops.cpp:10768-10809`
+  および非融合 autoregressive `src/models/delta-net-base.cpp:289-371` — 数式は同一:
+  `S ← S·exp(g)`(head 毎スカラー減衰)→ `Δ[j] = (v[j] − Σ_i S[i][j]k[i])·β` → `S[i][j] += k[i]Δ[j]`
+  → `o[j] = (Σ_i S[i][j]q[i])·(1/√128)`
+- MoE: `src/llama-graph.cpp:1799-2148`(softmax 先行 → argsort top-8 → 和正規化 → silu(gate)·up →
+  down → ×weight → 8 和; tie-break は fp 実装では**未定義**(std::sort 不安定))
+- 単項 op: silu/sigmoid/softplus(x>20→x)/l2_norm(x/max(√Σx²,eps))/rms_norm(1/√(mean+eps))/
+  ssm_conv(窓 4 前方 dot)/soft_max: `ggml-cpu/vec.h:936-1048, unary-ops.cpp:80, ops.cpp:3795-5502,9494,10671`
+- RoPE: `ggml-cpu/ops.cpp:5766-6031`(theta_scale = freq_base^(−2/64)、NEOX ペア、64 以降素通し)
+
+---
+
+## 2. Canonical class の定義(何を不変量とするか)
+
+- **重み**: blob のバイト列(既存 receipt の model hash と同一物)。
+- **整数意味論**: 本書 §4–§9 の固定小数点演算列。丸め点は全て pin(RNE または明示 floor)。
+- **決定性**: 全段整数 → reduction 順序・カーネル・ベンダ・ISA 非依存(inc1–4a で実証済みの性質)。
+- **出力**: greedy argmax token 列(低 index tie-break)と、その上の commitment。
+- fp 版とは**別クラス**(fp 品質をどこまで追跡するかは G3 で実測報告 — 捏造しない)。
+
+## 3. スケール表現
+
+- 0.5B hifi の **Q60 固定小数点(SC=60, HALF, RNE)+ i128 ホスト演算**をそのまま採用(実証済み)。
+- fp16 → exact 整数: 値 = mant·2^(e−25)(normal: mant = 1024+frac10, e=exp5; subnormal mant=frac10,
+  e=0 扱い)。fp32 → mant·2^(e−150)。**ビット操作のみ、fp 演算ゼロ**。
+- Metal オンデバイスでスケール代数が要る箇所は設計済みの正規化 (m0,e)+mulhi(親設計 §8)を使う。
+  ただし QI35-5 の第一段は CUDA-mirror 構成(GEMM=GPU 整数、スケール代数=host i128)なので不要。
+
+## 4. GEMM — Q4_K / Q6_K を**直接**整数消費する
+
+**Q4_K**(superblock 256 = 32×8 sub-block; 16B ヘッダ + 128B nibble):
+`w[i] = d·sc_j·q[i] − dmin·m_j`(q∈[0,15], sc_j,m_j∈[0,63] 6-bit)。行方向(k 方向)dot は
+
+```
+dot_j  = Σ_{i∈sub_j} x_i·q_i      (x: A24 → |x|≤2^23;  |dot_j| ≤ 2^32.3 → i64)
+sum_j  = Σ_{i∈sub_j} x_i          (|sum_j| ≤ 2^28)
+acc    = Σ_j [ (d_mant·sc_j)·dot_j·2^{e_d} − (dmin_mant·m_j)·sum_j·2^{e_dm} ]
+```
+
+d_mant·sc_j < 2^17、積 ≤ 2^49.3 → **i64 に収まり、指数アライン(行内最小指数へシフト)後の総和は
+CPU=i128 / GPU=2-word (hi,lo) i64 で exact 累積**。丸めは発生しない(有理数の exact 和)。
+**Q6_K**(256 = 16×16; sc int8 符号付き, w = d·sc_j·(q−32)): 同型で dmin 項なし。
+行スケールは Q60 に正規化した `colsq[o]`(= 2^{e_row}·…)として吐き、以降は 0.5B hifi の
+`proj()`(colsq/cmax → ratio → apply → aq)と同一代数。**bias は本モデルに存在しない**(全 GEMM bias 無し)。
+
+F32/F16 重み(router / norm γ / ssm_a / ssm_dt / conv1d / shexp gate)は**ロード時に exact 分解 →
+per-tensor Q 固定小数点へ pinned RNE 変換**(決定的、blob バイトのみに依存)。
+
+## 5. 活性量子化 — **per-token A24**
+
+- aq() は hifi と同じ(ALVL=2^23−1、符号付き丸め、scale=amax·cur/ALVL)だが、**必ず token 行単位**。
+  理由: prefill(複数 token 同時)と decode(1 token)で量子化が変わらないこと = KV cache /
+  逐次一致の前提。0.5B 参照(テンソル一括 amax)からの意図的変更点として pin する。
+- residual stream は i64 値 + per-token スケール(hifi と同じ持ち方)。
+
+## 6. 非線形 — 全て pinned 整数 LUT / 整数反復
+
+| op | 実装(**G2 で較正・確定** — [evidence](evidence/canonical-int-qwen36-layer-g2-2026-07-20.md)) | 状態 |
+|---|---|---|
+| softmax exp | **[0,8) 1/2048 刻み 16384 entry Q20**(0.5B の [0,4)×1/512 から拡張 — 35B router 差は ~7.2)、範囲外→0 | 確定 |
+| sigmoid / SiLU / β / attention gate / shexp gate | 16384×(1/512) [−16,16) Q16、SiLU = x·σ表[x]、域外 clamp | 確定 |
+| softplus(α+dt) | 16384×(1/512) [−16,16) 出力 Q16、x>20→x(ggml 準拠) | 確定 |
+| decay γ=exp(g), g≤0 | **[−16,0] 1/2048 刻み 32769 entry Q30**、g<−16→0(実測 g absmean 8.8) | 確定 |
+| RMSNorm(attn_norm/post_norm/q,k_norm/ssm_norm) | Σx² → 整数 isqrt。**eps=1e-6 を整数で pin**: `EPS_Q40=1,099,512` / `EPS_Q48=281,474,977`、可変スケール入力は per-token `eps_int=EPS_Q40·U²>>40`(U=2^60/scale)。**+1 近似は不可** — 減衰 head は eps-floor 支配(G2 で 29× ずれる実測) | 確定 |
+| L2 norm(DeltaNet q,k) | x·2^20 / max(isqrt(Σx²),1)(ggml の分母 floor 意味論)→ 単位 Q20 | 確定 |
+| RoPE cos/sin | Q30、32 ペア × SMAX pos、テーブルのバイト列を成果物として pin | 確定 |
+| 1/√128(DeltaNet 読み出し) | Q30 定数 RNE pin | 確定 |
+| 1/16(attention scale) | 右シフト 4 の exact 有理数 | — |
+
+## 7. DeltaNet 整数意味論(per-token が定義、prefill は同ビット)
+
+状態 S: **Q24 固定小数点・i64 演算で閉じる**(G2 実測 |S|≤10 → 積和 ≤2^55。GPU に i128 不要)
+128×128×32head×30 層 ≈ 63MB(i32 格納可)。conv 窓と v は**絶対 Q16**(実測 ±35)、
+q/k は L2 norm 後 **Q20 単位ベクトル**、β/softplus Q16、γ Q30。v-head h ↔ k-head **h%16**(タイル)。
+1 token の列(丸め点 = ★のみ、他は exact):
+
+1. qkv_mixed = W_qkv GEMM(§4)→ per-token aq ★
+2. conv 窓 [state(3), 今 token] の 4-tap 整数 dot(conv 重みは pinned 整数)→ SiLU LUT ★ → conv state 更新(整数値そのまま保存)
+3. q,k 分割 → L2 norm ★(head 128 毎)、k-head 16 → v-head 32 へ複製
+4. β = σ表[β_proj] ★、g = ssm_a ⊙ softplus表[α_proj + dt] ★、γ = exp表[g] ★
+5. S ← (S·γ) ★RNE→QS;  Δ[j] = (v[j] − Σ_i S[i][j]k[i]·2^{−…}) ★·β ★;  S[i][j] += k[i]Δ[j] ★RNE→QS
+6. o[j] = Σ_i S[i][j]q[i] ★ × (1/√128)Q30 ★
+7. o を per-head RMSNorm(ssm_norm)★ × SiLU(z)★ → aq ★ → W_out GEMM(§4)
+
+**prefill**: 射影 GEMM(1,2 の GEMM 部と 7)は全 token バッチで GPU 実行可(token 独立)。
+状態再帰(5,6)は token 順に実行(≈0.5M 積和/token で軽い)。整数なので**逐次 decode と bit 一致**。
+状態 checkpoint(spec §7 の N=64 token 毎 hash)は S+conv state+KV の整数バイト列に対して自然に定義できる。
+
+## 8. Full attention 層整数意味論
+
+1. QG = W_q GEMM → interleave 分割(q: head h の [512h, 512h+256)、gate: [512h+256, 512h+512))
+2. q,k per-head RMSNorm ★(γ=attn_q_norm/attn_k_norm)→ RoPE(Q30 表、64 次元、ペア (i,i+32))★
+3. KV cache: k,v を**絶対 Q16 固定小数点**で保存(per-token スケールだと A·V の異 token 混合で
+   共通化が要る — 絶対 Q16 なら逐次 decode ≡ prefill が自明。範囲は q/k norm 後 ±10 で安全)
+4. scores = q·k dot(i128)× 1/16 → hifi 方式 max 減算 + exp 表 ★ → A·V 整数除算 ★(fdiv+HALF pin)
+5. × σ表[gate] ★ → aq ★ → W_o GEMM
+GQA: kv head = h/8。mask: 因果のみ(pre-softmax の別 bias 無し、sinks 無し)。
+
+## 9. MoE 整数意味論
+
+1. logits = router GEMM(F32→pinned Q24 重み、i128 acc)
+2. softmax: max 減算 → exp 表 ★ → Σ → 各 top-8 重み w_i = fdiv(e_i·2^30 + Σ/2, Σ) ★
+3. **top-8 = 整数 desc 比較、同点は低 index**(fp の std::sort 不安定性を canonical 側で確定)
+4. 分母 Σw_top8 で再正規化 ★(fp の F16-min クランプは整数では Σ≥1 floor として pin)
+5. 各 expert: gate/up GEMM(Q4_K §4)→ SiLU 表 ★ × up → aq ★ → down GEMM(Q6_K)→ ×w_i ★ → 8 本 exact 和
+6. shared expert: 同型 + σ表[shexp gate] ★、routed 和に exact 加算
+expert GEMM は「選ばれた 8 expert の行だけ」を実行(offset 計算は tensor 3 次元目 stride)。
+
+## 10. メモリ予算(M1 Max 32GB)
+
+| 項目 | 量 |
+|---|---|
+| blob mmap(重み直読) | 23.9GB(クリーン evict 可) |
+| DeltaNet S + conv state | ~66MB |
+| KV cache(4K ctx, 10 層) | ~35MB(整数) |
+| LUT/RoPE 表/スケール表 | <50MB |
+| 活性ワーク | <200MB |
+| 合計 | ~24.3GB — 32GB 内、余裕 ~7GB |
+
+## 11. 実装ゲート(hardware-validated、捏造なし)
+
+- **G1(op)**: Q4_K/Q6_K 直接整数 GEMM を Python bigint exact 参照と突合、Rust x86/aarch64 でビット一致
+- **G2(layer)【完了 2026-07-20】**: blk.0(DeltaNet)+ blk.3(attn)+ MoE を llama.cpp CPU fp32 の
+  実活性と全 77 チェックポイント照合 — **layer 出力 ≤3%・状態 rmse ~1e-4・MoE top-8 全一致**
+  ([evidence](evidence/canonical-int-qwen36-layer-g2-2026-07-20.md)、`qi35_int_ref.py`)
+- **G3(model)**: 40 層 greedy を fp(CPU/Metal)と複数 prompt で token 一致率測定(結果は実測値のみ記載)
+- **G4(Metal)**: 整数 Metal ≡ 整数 CPU のビット一致(fingerprint)
+- **G5(CUDA)**: RTX box 復帰時に同 fingerprint(モデルは VRAM 16GB に載らないため CPU offload 構成)
+
+## 12. 正直な限界
+
+- fp 品質追跡(G3 の一致率)は**未測定**。0.5B hifi は 12/12 だったが、35B/Q4_K/長系列で同等とは限らない。
+- 本書の丸め点(★)のうち QS 等の定数は QI35-3 の実データ較正後に pin(現時点は仕様スロット)。
+- 長文(YaRN 域)・vision・MTP・非 greedy sampler は対象外(テキスト greedy のみ)。
+- fp 実装の MoE tie-break 未定義により、logit 完全同点の手では fp と本 class は原理的に分岐し得る。
+- 32GB 機で fp llama.cpp と整数版を**同時**駐在させると swap する(逐次実行で運用)。
diff --git a/docs/evidence/canon_attn.cu b/docs/evidence/canon_attn.cu
new file mode 100644
index 0000000000000000000000000000000000000000..f1903c2dbf8ae78f159837e6f6175951d86f83cf
--- /dev/null
+++ b/docs/evidence/canon_attn.cu
@@ -0,0 +1,136 @@
+// inc4b-2b: CUDA (NVIDIA GPU) port of the fully-integer attention block. Host parses layer0.bin and uploads
+// clean device arrays; a single-thread kernel runs the block with __int128 scales — same integer semantics
+// as the Rust/Python reference. Must reproduce fingerprint dea9a75ba85b1352.
+// Build/run:  nvcc -O3 -arch=sm_89 canon_attn.cu -o canon_attn_cu && ./canon_attn_cu layer0.bin
+#include <cstdio>
+#include <cstdint>
+#include <vector>
+#include <cstring>
+#include <cuda_runtime.h>
+typedef long long i64; typedef __int128 i128;
+static const int SC=30, D=896, NH=14, NKV=2, HD=64, S=4, FF=4864;
+static const unsigned long long TARGET=0x906729150a5a926aULL; // full-layer (4b-3)
+
+// ---------- host parse ----------
+struct Buf{ std::vector<unsigned char> b; long p=0;
+  unsigned u32(){unsigned v;memcpy(&v,&b[p],4);p+=4;return v;} int i32(){int v;memcpy(&v,&b[p],4);p+=4;return v;}
+  i64 i64_(){i64 v;memcpy(&v,&b[p],8);p+=8;return v;} unsigned char u8(){return b[p++];}
+};
+__host__ __device__ static i128 qm(i64 m0,i64 sh){ i64 e=sh-1; return e>=0?((i128)m0<<e):(((i128)m0+((i128)1<<(-e-1)))>>(-e)); }
+
+// device scratch (single thread, no races)
+__device__ i64 dyg[S*D], dxnq[S*D], dqq[S*NH*HD], dkq[S*NKV*HD], dvq[S*NKV*HD];
+__device__ i64 dscores[NH*S*S], dpn[NH*S*S], dps[NH*S], dattn[S*D], daqa[S*D], doacc[S*D], dacc[S*FF];
+__device__ i128 dcolsq[FF];
+__device__ i64 dhout[S*D], dxn2[S*D], dgate[S*FF], dup[S*FF], dact[S*FF], dhmul[S*FF]; // 4b-3 MLP scratch
+
+__device__ static i128 HALFd=(i128)1<<29, ALVLd=32767;
+__device__ i128 ap(i128 a,i128 s){return (a*s+HALFd)>>SC;}
+__device__ i128 mul128(i128 a,i128 b){return (a*b+HALFd)>>SC;}
+__device__ i128 sfrom(i128 amax,i128 cur){return (amax*cur)/ALVLd;}
+__device__ i128 fdiv(i128 a,i128 b){i128 q=a/b,r=a%b; if(r!=0&&((r<0)!=(b<0)))return q-1; return q;}
+__device__ i128 isqrtd(i128 n){if(n<=0)return 0; i128 x=n,y=(x+1)/2; while(y<x){x=y;y=(x+n/x)/2;} return x;}
+__device__ i128 aqd(i64* v,int n,i128 cur){ i64 am=1; for(int i=0;i<n;i++){i64 a=v[i]<0?-v[i]:v[i]; if(a>am)am=a;} i128 amc=am;
+  for(int i=0;i<n;i++){i128 xi=v[i],sg=xi>0?amc:(xi<0?-amc:0); v[i]=(i64)fdiv(xi*ALVLd*2+sg,2*amc);} return sfrom(amc,cur);}
+
+// proj: acc into dacc/out, returns scale via out param
+__device__ i128 projd(const signed char* w,int oc,int inn,const i128* wsq,const i64* bv,i128 bsq,
+                      const i64* xnq,i128 xnsq,i64* out){
+  for(int s=0;s<S;s++)for(int o=0;o<oc;o++){i64 a=0;for(int d=0;d<inn;d++)a+=xnq[s*inn+d]*(i64)w[o*inn+d]; dacc[s*oc+o]=a;}
+  for(int o=0;o<oc;o++) dcolsq[o]=mul128(xnsq,wsq[o]);
+  i128 cmax=dcolsq[0]; for(int o=1;o<oc;o++) if(dcolsq[o]>cmax)cmax=dcolsq[o];
+  for(int o=0;o<oc;o++){ i128 cs=dcolsq[o]; i64 b= (bv&&cs)? (i64)(fdiv((i128)bv[o]*bsq*((i128)1<<SC)+(cs>>1),cs)>>SC):0;
+    i128 r=(cs<<SC)/cmax; for(int s=0;s<S;s++){ i128 ab=(i128)dacc[s*oc+o]+b; out[s*oc+o]=(i64)ap(ab,r);} }
+  return aqd(out,S*oc,cmax);
+}
+
+__global__ void run(const signed char* qw,const i128* qsc,const i64* qb,i128 qbsc,
+                    const signed char* kw,const i128* ksc,const i64* kb,i128 kbsc,
+                    const signed char* vw,const i128* vsc,const i64* vb,i128 vbsc,
+                    const signed char* ow,const i128* osc,
+                    const signed char* xv8,const i128* xsc,const i64* gv,i128 gamsc,
+                    const i64* pav,i128 pasc,const signed char* gw,const i128* gsc,
+                    const signed char* uw,const i128* usc,const signed char* dw,const i128* dsc,
+                    const i64* cosq,const i64* sinq,const i64* expl,const i64* sig,i64* hout){
+  if(blockIdx.x*blockDim.x+threadIdx.x!=0) return;
+  // RMSNorm
+  for(int s=0;s<S;s++){ i128 ss=0; for(int d=0;d<D;d++){i128 x=xv8[s*D+d]; ss+=x*x;} i128 mean=ss/D+1;
+    i64 inv=(i64)isqrtd(((i128)1<<40)/mean); for(int d=0;d<D;d++) dyg[s*D+d]=(i64)xv8[s*D+d]*inv*gv[d]; }
+  i128 xnsq0=aqd(dyg,S*D,(i128)1<<SC); for(int i=0;i<S*D;i++) dxnq[i]=dyg[i];
+  i128 xnsq=mul128(mul128(xnsq0,qm(1,11)),gamsc);
+  i128 qsq=projd(qw,NH*HD,D,qsc,qb,qbsc,dxnq,xnsq,dqq);
+  i128 ksq=projd(kw,NKV*HD,D,ksc,kb,kbsc,dxnq,xnsq,dkq);
+  i128 vsq=projd(vw,NKV*HD,D,vsc,vb,vbsc,dxnq,xnsq,dvq);
+  // rope (in place) using src copies
+  for(int nh=0; nh<2; nh++){ i64* x=nh?dkq:dqq; int nn=nh?NKV:NH; i64 src[S*NH*HD];
+    for(int i=0;i<S*nn*HD;i++) src[i]=x[i];
+    for(int s=0;s<S;s++)for(int h=0;h<nn;h++)for(int d=0;d<HD;d++){int base=(s*nn+h)*HD;
+      i64 rh=d<HD/2?-src[base+d+HD/2]:src[base+d-HD/2]; x[base+d]=(src[base+d]*cosq[s*HD+d]+rh*sinq[s*HD+d]+16384)>>15;} }
+  int gg=NH/NKV;
+  for(int h=0;h<NH;h++){int kvh=h/gg;for(int s=0;s<S;s++)for(int t=0;t<S;t++){i64 a=0;
+    for(int d=0;d<HD;d++)a+=dqq[(s*NH+h)*HD+d]*dkq[(t*NKV+kvh)*HD+d]; dscores[(h*S+s)*S+t]=a;}}
+  i128 c8=mul128(qsq,ksq)*8;
+  for(int h=0;h<NH;h++)for(int s=0;s<S;s++){ i64 m=dscores[(h*S+s)*S+0]; for(int t=1;t<=s;t++){i64 v=dscores[(h*S+s)*S+t]; if(v>m)m=v;}
+    i64 sm=0; for(int t=0;t<=s;t++){ i128 dd=ap((i128)(m-dscores[(h*S+s)*S+t]),c8); if(dd<0)dd=0; if(dd>255)dd=255;
+      i64 e=expl[(int)dd]; dpn[(h*S+s)*S+t]=e; sm+=e;} dps[h*S+s]=sm; }
+  for(int h=0;h<NH;h++){int kvh=h/gg;for(int s=0;s<S;s++){ i128 den=dps[h*S+s];
+    for(int d=0;d<HD;d++){ i128 acc=0; for(int t=0;t<=s;t++) acc+=(i128)dpn[(h*S+s)*S+t]*(i128)dvq[(t*NKV+kvh)*HD+d];
+      dattn[s*D+h*HD+d]=(i64)(fdiv(acc*((i128)1<<SC)+(den>>1),den)>>SC);}}}
+  for(int i=0;i<S*D;i++) daqa[i]=dattn[i]; i128 aqsq=aqd(daqa,S*D,vsq);
+  for(int s=0;s<S;s++)for(int d2=0;d2<D;d2++){i64 a=0;for(int d=0;d<D;d++)a+=daqa[s*D+d]*(i64)ow[d2*D+d]; doacc[s*D+d2]=a;}
+  for(int s=0;s<S;s++){ i128 xs=xsc[s]; for(int d2=0;d2<D;d2++){ i128 oc=mul128(aqsq,osc[d2]); i128 r=(oc<<SC)/xs;
+    dhout[s*D+d2]=(i64)xv8[s*D+d2]+(i64)ap((i128)doacc[s*D+d2],r);}}
+  // ---- SwiGLU MLP (4b-3) ----
+  for(int s=0;s<S;s++){ i128 ss=0; for(int d=0;d<D;d++){i128 x=dhout[s*D+d]; ss+=x*x;} i128 mean=ss/D+1;
+    i64 inv=(i64)isqrtd(((i128)1<<40)/mean); for(int d=0;d<D;d++) dyg[s*D+d]=dhout[s*D+d]*inv*pav[d]; }
+  i128 s0=aqd(dyg,S*D,(i128)1<<SC); for(int i=0;i<S*D;i++) dxn2[i]=dyg[i];
+  i128 xn2sq=mul128(mul128(s0,qm(1,11)),pasc);
+  i128 gsq=projd(gw,FF,D,gsc,(const i64*)0,0,dxn2,xn2sq,dgate);
+  i128 usq=projd(uw,FF,D,usc,(const i64*)0,0,dxn2,xn2sq,dup);
+  for(int i=0;i<S*FF;i++){ i128 idx=ap((i128)dgate[i],gsq<<7)+2048; if(idx<0)idx=0; if(idx>4095)idx=4095; dact[i]=dgate[i]*sig[(int)idx]; }
+  i128 spre=aqd(dact,S*FF,gsq); i128 asq=spre>>16;               // dact now int16
+  for(int i=0;i<S*FF;i++) dhmul[i]=dact[i]*dup[i];
+  i128 hsq=mul128(asq,usq); i128 hqsq=aqd(dhmul,S*FF,hsq);        // dhmul now int16
+  i128 msq=projd(dw,D,FF,dsc,(const i64*)0,0,dhmul,hqsq,dacc);    // mlp out into dacc [S*D]
+  for(int s=0;s<S;s++){ i128 xs=xsc[s]; i128 r=(msq<<SC)/xs; for(int d2=0;d2<D;d2++) hout[s*D+d2]=dhout[s*D+d2]+(i64)ap((i128)dacc[s*D+d2],r); }
+}
+
+// host parse helpers
+static void rd_w2d(Buf& b, std::vector<signed char>& w, std::vector<i128>& sq){
+  b.u8(); int r=b.u32(), co=b.u32(); w.resize((long)r*co); for(long i=0;i<(long)r*co;i++) w[i]=(signed char)b.u8();
+  int ns=b.u32(); sq.resize(ns); for(int i=0;i<ns;i++){i64 m=b.i32(),s=b.i32(); sq[i]=qm(m,s);} }
+static void rd_v1d(Buf& b, std::vector<i64>& v, i128& sq){
+  b.u8(); int n=b.u32(); b.u32(); v.resize(n); for(int i=0;i<n;i++) v[i]=b.i32(); b.u32(); i64 m=b.i32(),s=b.i32(); sq=qm(m,s); }
+
+int main(int argc,char** argv){
+  const char* path=argc>1?argv[1]:"layer0.bin"; FILE* f=fopen(path,"rb"); fseek(f,0,SEEK_END); long n=ftell(f); fseek(f,0,SEEK_SET);
+  Buf b; b.b.resize(n); fread(b.b.data(),1,n,f); fclose(f); b.p=8;
+  std::vector<i64> gv,qb,kb,vb,pav; i128 gamsc,qbsc,kbsc,vbsc,pasc;
+  std::vector<signed char> qw,kw,vw,ow,xv,gw_,uw_,dw_; std::vector<i128> qsc,ksc,vsc,osc,xsc,gsc,usc,dsc;
+  rd_v1d(b,gv,gamsc); rd_w2d(b,qw,qsc); rd_v1d(b,qb,qbsc); rd_w2d(b,kw,ksc); rd_v1d(b,kb,kbsc);
+  rd_w2d(b,vw,vsc); rd_v1d(b,vb,vbsc); rd_w2d(b,ow,osc); rd_w2d(b,xv,xsc);
+  rd_v1d(b,pav,pasc); rd_w2d(b,gw_,gsc); rd_w2d(b,uw_,usc); rd_w2d(b,dw_,dsc);
+  std::vector<i64> cosq(S*HD),sinq(S*HD),expl(256),sig(4096);
+  for(auto* a:{&cosq,&sinq}) for(auto& x:*a) x=b.i64_(); for(auto& x:expl) x=b.i64_(); for(auto& x:sig) x=b.i64_();
+  // upload
+  auto up=[&](auto& v){ using T=typename std::decay<decltype(v)>::type::value_type; T* d; cudaMalloc(&d,v.size()*sizeof(T)); cudaMemcpy(d,v.data(),v.size()*sizeof(T),cudaMemcpyHostToDevice); return d; };
+  auto *dqw=up(qw),*dkw=up(kw),*dvw=up(vw),*dow=up(ow),*dxv=up(xv);
+  auto *dqsc=up(qsc),*dksc=up(ksc),*dvsc=up(vsc),*dosc=up(osc),*dxsc=up(xsc);
+  auto *dgv=up(gv),*dqb=up(qb),*dkb=up(kb),*dvb=up(vb),*dcos=up(cosq),*dsin=up(sinq),*dexp=up(expl);
+  auto *dpav=up(pav),*dsig=up(sig);                 // i64*
+  auto *dgw=up(gw_),*duw=up(uw_),*ddw=up(dw_);       // signed char*
+  auto *dgsc=up(gsc),*dusc=up(usc),*ddsc=up(dsc);    // i128*
+  i64* dhout; cudaMalloc(&dhout,S*D*sizeof(i64));
+  run<<<1,1>>>(dqw,dqsc,dqb,qbsc, dkw,dksc,dkb,kbsc, dvw,dvsc,dvb,vbsc, dow,dosc,
+               dxv,dxsc,dgv,gamsc, dpav,pasc,dgw,dgsc, duw,dusc,ddw,ddsc, dcos,dsin,dexp,dsig, dhout);
+  cudaError_t e=cudaDeviceSynchronize(); if(e){printf("cuda err %s\n",cudaGetErrorString(e));return 1;}
+  std::vector<i64> hout(S*D); cudaMemcpy(hout.data(),dhout,S*D*sizeof(i64),cudaMemcpyDeviceToHost);
+  unsigned long long h=0xcbf29ce484222325ULL; for(i64 v:hout){ unsigned char* p=(unsigned char*)&v; for(int k=0;k<8;k++){h^=p[k]; h*=0x100000001b3ULL;} }
+  cudaDeviceProp pr; cudaGetDeviceProperties(&pr,0);
+  printf("backend      = NVIDIA CUDA GPU (%s sm_%d%d)\n",pr.name,pr.major,pr.minor);
+  printf("block-out FNV= %016llx\n",h);
+  printf("TARGET       = %016llx\n",TARGET);
+  printf("MATCH        = %s\n", h==TARGET?"YES (byte-identical to Rust/Python reference)":"NO");
+  printf("hout[0..4]   = %lld %lld %lld %lld\n",(long long)hout[0],(long long)hout[1],(long long)hout[2],(long long)hout[3]);
+  return 0;
+}
diff --git a/docs/evidence/canon_attn.py b/docs/evidence/canon_attn.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ec57a5532f59d3c2fded72bab0b9cb08726d29d
--- /dev/null
+++ b/docs/evidence/canon_attn.py
@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+# inc4b-2a: integer attention block (Qwen2.5-0.5B layer 0) consuming the real `.canon` W8A8 artifact.
+# Validates CORRECTNESS: the integer block (int8 matmuls + integer RMSNorm/RoPE/softmax) matches a full-fp
+# reference computed from the SAME dequantized weights. Scalar scales are carried as fp here (they become
+# fixed-point in the 4b-2b cross-backend port). Heavy tensor compute is all integer.
+import sys, json, struct, numpy as np
+
+CANON = sys.argv[1] if len(sys.argv) > 1 else "/root/models/qwen05.canon"
+D, NH, NKV, HD, THETA = 896, 14, 2, 64, 1000000.0
+S = 4  # prefill length
+
+def read_canon(path):
+    with open(path, "rb") as f:
+        assert f.read(8) == b"CANONv1\n"
+        n = struct.unpack("<Q", f.read(8))[0]
+        hdr = json.loads(f.read(n))
+        body = f.read()
+    out = {}
+    for t in hdr["tensors"]:
+        nm, k, shp = t["name"], t["kind"], t["shape"]
+        if k == "w2d_int8_pcs":
+            o, i = shp
+            w = np.frombuffer(body[t["w_off"]:t["w_off"] + o * i], dtype=np.int8).reshape(o, i)
+            sc = np.frombuffer(body[t["s_off"]:t["s_off"] + o * 8], dtype=np.int32).reshape(o, 2)
+            scale = sc[:, 0].astype(np.float64) * 2.0 ** (sc[:, 1].astype(np.float64) - 31)
+            out[nm] = ("w", w, scale)
+        else:  # v1d_int32_fp
+            v = np.frombuffer(body[t["w_off"]:t["w_off"] + shp[0] * 4], dtype=np.int32)
+            m0, sh = struct.unpack("<ii", body[t["s_off"]:t["s_off"] + 8])
+            out[nm] = ("v", v, m0 * 2.0 ** (sh - 31))
+    return out
+
+T = read_canon(CANON)
+def wdeq(n): _, w, s = T[n]; return w.astype(np.float64) * s[:, None]   # [out,in] fp
+def vdeq(n): _, v, s = T[n]; return v.astype(np.float64) * s            # [n] fp
+L = "model.layers.0."
+Wq, Wk, Wv, Wo = wdeq(L+"self_attn.q_proj.weight"), wdeq(L+"self_attn.k_proj.weight"), wdeq(L+"self_attn.v_proj.weight"), wdeq(L+"self_attn.o_proj.weight")
+bq, bk, bv = vdeq(L+"self_attn.q_proj.bias"), vdeq(L+"self_attn.k_proj.bias"), vdeq(L+"self_attn.v_proj.bias")
+gin = vdeq(L+"input_layernorm.weight")
+# input hidden states = real embedding rows for a few token ids
+Wemb, semb = T["model.embed_tokens.weight"][1], T["model.embed_tokens.weight"][2]
+ids = [9707, 11, 1879, 30][:S]
+X = np.stack([Wemb[i].astype(np.float64) * semb[i] for i in ids])   # [S, D]
+
+# ---------- RoPE tables (offline fp -> pinned fixed-point Q15) ----------
+inv_freq = 1.0 / (THETA ** (np.arange(0, HD, 2) / HD))              # [HD/2]
+pos = np.arange(S)
+ang = np.outer(pos, inv_freq)                                       # [S, HD/2]
+cos_h, sin_h = np.cos(ang), np.sin(ang)
+cos_f = np.concatenate([cos_h, cos_h], axis=1)                      # [S, HD]
+sin_f = np.concatenate([sin_h, sin_h], axis=1)
+cosQ = np.clip(np.rint(cos_f * 32768), -32768, 32767).astype(np.int64)
+sinQ = np.clip(np.rint(sin_f * 32768), -32768, 32767).astype(np.int64)
+def rot_half_fp(x): return np.concatenate([-x[..., HD//2:], x[..., :HD//2]], axis=-1)
+def rope_fp(x):  # x [S,H,HD]
+    return x * cos_f[:, None, :] + rot_half_fp(x) * sin_f[:, None, :]
+def rope_int(xq):  # xq int8 [S,H,HD] -> int8, scale preserved
+    rh = np.concatenate([-xq[..., HD//2:].astype(np.int64), xq[..., :HD//2].astype(np.int64)], axis=-1)
+    v = (xq.astype(np.int64) * cosQ[:, None, :] + rh * sinQ[:, None, :] + 16384) >> 15
+    return np.clip(v, -127, 127).astype(np.int8)
+
+def qdyn(Tf):  # dynamic per-tensor int8 quant of fp tensor -> (int8, scale)
+    a = float(np.max(np.abs(Tf))) or 1.0
+    s = a / 127.0
+    return np.clip(np.rint(Tf / s), -127, 127).astype(np.int8), s
+def imatmul(aq, wq): return aq.astype(np.int64) @ wq.astype(np.int64).T  # [S,in]x[out,in]->[S,out]
+def rms_int(xq):  # int8 [S,D] -> normalized int8 [S,D] + scale (gamma folded), scale-invariant
+    ss = np.sum(xq.astype(np.int64)**2, axis=1)                    # [S]
+    mean = ss // D + 1
+    inv = np.floor(np.sqrt((1 << 32) / mean)).astype(np.int64)     # ~2^16/sqrt(mean) per token
+    y = (xq.astype(np.int64) * inv[:, None]) >> 16                 # x/rms in ~int scale
+    yg = y * np.rint(gin * (1 << 12)).astype(np.int64)             # * gamma(Q12)
+    outs = 1.0 / (1 << 12)
+    yq, s2 = qdyn(yg.astype(np.float64))
+    return yq, s2 * outs  # scale bookkeeping (fp scalar; fixed-point in 4b-2b)
+
+# ---------- integer block ----------
+Xq, Xs = qdyn(X)
+xn_q, xn_s = rms_int(Xq)
+# QKV: acc = xn_q @ Wq_int^T ; dequant-ish scale = xn_s * wq_scale[o]; + bias ; then reshape
+def proj_int(xn_q, xn_s, wname, bfp):
+    _, wq, wsc = T[wname]
+    acc = imatmul(xn_q, wq)                       # [S, out] int64
+    outf = acc.astype(np.float64) * (xn_s * wsc)[None, :] + bfp[None, :]  # to fp (scalar scales fp here)
+    return outf
+qf = proj_int(xn_q, xn_s, L+"self_attn.q_proj.weight", bq).reshape(S, NH, HD)
+kf = proj_int(xn_q, xn_s, L+"self_attn.k_proj.weight", bk).reshape(S, NKV, HD)
+vf = proj_int(xn_q, xn_s, L+"self_attn.v_proj.weight", bv).reshape(S, NKV, HD)
+# quantize q,k,v to int8 for integer RoPE + attention
+qq, qs = qdyn(qf); kq, ks = qdyn(kf); vq, vs = qdyn(vf)
+qq, kq = rope_int(qq), rope_int(kq)
+# GQA expand kv -> NH heads
+kq14 = np.repeat(kq, NH // NKV, axis=1); vq14 = np.repeat(vq, NH // NKV, axis=1)
+# scores[h,s,t] = sum_d qq[s,h,d]*kq14[t,h,d]
+scores = np.einsum('shd,thd->hst', qq.astype(np.int64), kq14.astype(np.int64))  # int
+# integer softmax over t with causal mask; temperature C = qs*ks/sqrt(HD)
+C = qs * ks / np.sqrt(HD)
+# exp LUT (integer Horner Q16), same as inc4a
+def build_exp_lut(nterms=28):
+    ONE = 1 << 16; t = np.zeros(256, np.int64)
+    for d in range(256):
+        x = -d * (ONE // 64); e = ONE; k = nterms
+        while k >= 1: e = ONE + ((x * e) // ONE) // k; k -= 1
+        t[d] = max(0, e)
+    return t
+EXP = build_exp_lut()
+# accuracy check of the integer exp-LUT vs true exp
+_dd = np.arange(256); _true = np.exp(-_dd / 64) * (1 << 16)
+print(f"exp-LUT max rel err vs true exp = {np.max(np.abs(EXP - _true) / np.maximum(_true,1)):.4f}")
+probs = np.zeros((NH, S, S), np.float64)
+for h in range(NH):
+    for s in range(S):
+        row = scores[h, s, :s+1]
+        m = row.max()
+        d = np.clip(((m - row).astype(np.float64) * C * 64).round().astype(int), 0, 255)  # C*gap in exp-arg units
+        e = EXP[d]; sm = int(e.sum())
+        p = (e.astype(np.int64) << 16) // sm
+        probs[h, s, :s+1] = p / (1 << 16)
+# DEBUG bisect
+def _rel(a, b): return float(np.sqrt(np.sum((a-b)**2) / (np.sum(b*b)+1e-12)))
+_fp_probs = np.zeros_like(probs)
+for h in range(NH):
+    for s in range(S):
+        r = scores[h, s, :s+1].astype(float) * C
+        p = np.exp(r - r.max()); p /= p.sum(); _fp_probs[h, s, :s+1] = p
+print(f"  dbg int-softmax vs fp-softmax(same scores) = {_rel(probs, _fp_probs):.4f}")
+print(f"  dbg q post-rope int-deq vs fp-rope(same qf)= {_rel(qq.astype(float)*qs, rope_fp(qf)):.4f}")
+print(f"  dbg C={C:.3e}  scores range=[{scores.min()},{scores.max()}]  probs[0,3]={np.round(probs[0,3],3)}")
+# A.V : out[s,h,d] = sum_t probs[h,s,t]*vf[t,h,d]  (fp probs * fp v carry the value scale)
+vf14 = np.repeat(vf.reshape(S, NKV, HD), NH // NKV, axis=1)   # [S, NH, HD]
+attn = np.einsum('hst,thd->shd', probs, vf14).reshape(S, D)
+# o_proj (integer matmul)
+aq, as_ = qdyn(attn)
+_, wo, wosc = T[L+"self_attn.o_proj.weight"]
+o = (imatmul(aq, wo).astype(np.float64) * (as_ * wosc)[None, :])
+h_out_int = X + o
+
+# ---------- full-fp reference (same dequantized weights) ----------
+def rms_fp(h, g): return h / np.sqrt(np.mean(h*h, axis=1, keepdims=True) + 1e-6) * g
+xn = rms_fp(X, gin)
+q = (xn @ Wq.T + bq).reshape(S, NH, HD); k = (xn @ Wk.T + bk).reshape(S, NKV, HD); v = (xn @ Wv.T + bv).reshape(S, NKV, HD)
+q, k = rope_fp(q), rope_fp(k)
+k14 = np.repeat(k, NH//NKV, axis=1); v14 = np.repeat(v, NH//NKV, axis=1)
+sc = np.einsum('shd,thd->hst', q, k14) / np.sqrt(HD)
+for h in range(NH):
+    for s in range(S):
+        sc[h, s, s+1:] = -1e30
+attn_fp = np.zeros((S, NH, HD))
+for h in range(NH):
+    p = np.exp(sc[h] - sc[h].max(axis=1, keepdims=True)); p /= p.sum(axis=1, keepdims=True)
+    attn_fp[:, h, :] = p @ v14[:, h, :]
+o_fp = attn_fp.reshape(S, D) @ Wo.T
+h_out_fp = X + o_fp
+
+# o_semi: int-PROJECTED q/k/v (fp values) run through FP attention -> isolates projection-quant amplification
+qsr, ksr = rope_fp(qf), rope_fp(kf)
+k14_ = np.repeat(ksr, NH//NKV, 1); v14_ = np.repeat(vf, NH//NKV, 1)
+sc_ = np.einsum('shd,thd->hst', qsr, k14_) / np.sqrt(HD)
+for h in range(NH):
+    for s in range(S): sc_[h, s, s+1:] = -1e30
+ao = np.zeros((S, NH, HD))
+for h in range(NH):
+    p = np.exp(sc_[h] - sc_[h].max(1, keepdims=True)); p /= p.sum(1, keepdims=True); ao[:, h, :] = p @ v14_[:, h, :]
+o_semi = ao.reshape(S, D) @ Wo.T
+# weight-only: fp activations xn @ int8-weight(dequant) -> isolates WEIGHT quant from ACTIVATION quant
+def proj_wonly(xn_fp, wname, bfp):
+    _, wq, wsc = T[wname]; return xn_fp @ (wq.astype(np.float64) * wsc[:, None]).T + bfp
+qw = proj_wonly(xn, L+"self_attn.q_proj.weight", bq).reshape(S, NH, HD)
+kw = proj_wonly(xn, L+"self_attn.k_proj.weight", bk).reshape(S, NKV, HD)
+vw = proj_wonly(xn, L+"self_attn.v_proj.weight", bv).reshape(S, NKV, HD)
+qwr, kwr = rope_fp(qw), rope_fp(kw); k14w = np.repeat(kwr, NH//NKV, 1); v14w = np.repeat(vw, NH//NKV, 1)
+scw = np.einsum('shd,thd->hst', qwr, k14w) / np.sqrt(HD)
+for h in range(NH):
+    for s in range(S): scw[h, s, s+1:] = -1e30
+aw = np.zeros((S, NH, HD))
+for h in range(NH):
+    p = np.exp(scw[h] - scw[h].max(1, keepdims=True)); p /= p.sum(1, keepdims=True); aw[:, h, :] = p @ v14w[:, h, :]
+o_wonly = aw.reshape(S, D) @ Wo.T
+# q per-tensor quant error (dequant vs qf)
+print(f"  dbg o_semi(W8A8-proj, fp-attn) vs o_fp = {_rel(o_semi, o_fp):.4f}   o_wonly(W8 only, fp-act) vs o_fp = {_rel(o_wonly, o_fp):.4f}")
+
+def rel(a, b): return float(np.sqrt(np.sum((a-b)**2) / (np.sum(b*b)+1e-12)))
+print(f"tokens={ids}  S={S}")
+print(f"rel err  qkv(q)     = {rel((imatmul(xn_q,T[L+'self_attn.q_proj.weight'][1]).astype(float)*(xn_s*T[L+'self_attn.q_proj.weight'][2])+bq), (xn@Wq.T+bq)):.4f}")
+print(f"rel err  o (attn)   = {rel(o, o_fp):.4f}   (attention output only)   ||o||/||X||={np.linalg.norm(o)/np.linalg.norm(X):.3f}")
+print(f"rel err  block out  = {rel(h_out_int, h_out_fp):.4f}   (int block vs full-fp, same quantized weights)")
+print(f"h_out_int[0,:4] = {np.round(h_out_int[0,:4],4)}")
+print(f"h_out_fp [0,:4] = {np.round(h_out_fp [0,:4],4)}")
diff --git a/docs/evidence/canon_attn.rs b/docs/evidence/canon_attn.rs
new file mode 100644
index 0000000000000000000000000000000000000000..30950dd96b4842670d370744042055ae0c74b930
--- /dev/null
+++ b/docs/evidence/canon_attn.rs
@@ -0,0 +1,187 @@
+// inc4b-2b: Rust (CPU) port of the fully-integer attention block. Reads layer0.bin (flat, no JSON), runs
+// the block with the EXACT integer semantics of canon_attn_int.py (i128 scales, i64 values, floor division
+// where Python uses //, arithmetic >>). Must reproduce the reference fingerprint dea9a75ba85b1352.
+//
+// Build/run:  rustc -O canon_attn.rs -o canon_attn && ./canon_attn layer0.bin
+
+use std::io::Read;
+
+const SC: u32 = 30;
+const HALF: i128 = 1 << 29;
+const ALVL: i128 = 32767;
+const D: usize = 896;
+const NH: usize = 14;
+const NKV: usize = 2;
+const HD: usize = 64;
+const S: usize = 4;
+const TARGET: u64 = 0x906729150a5a926a; // full-layer (4b-3)
+
+fn qm(m0: i64, shift: i64) -> i128 { let e = shift - 1; if e >= 0 { (m0 as i128) << e } else { ((m0 as i128) + (1i128 << (-e - 1))) >> (-e) } }
+fn apply(acc: i128, sq: i128) -> i128 { (acc * sq + HALF) >> SC }
+fn mul(a: i128, b: i128) -> i128 { (a * b + HALF) >> SC }
+fn scale_from(amax: i128, cur: i128) -> i128 { (amax * cur) / ALVL }
+fn fdiv(a: i128, b: i128) -> i128 { let q = a / b; let r = a % b; if r != 0 && (r < 0) != (b < 0) { q - 1 } else { q } } // floor
+fn isqrt(n: i128) -> i128 { if n <= 0 { return 0; } let mut x = n; let mut y = (x + 1) / 2; while y < x { x = y; y = (x + n / x) / 2; } x }
+fn aq(v: &[i64], cur: i128) -> (Vec<i64>, i128) {
+    let am = v.iter().map(|x| x.abs()).max().unwrap().max(1) as i128;
+    let q = v.iter().map(|&x| { let xi = x as i128; let sign = if xi > 0 { am } else if xi < 0 { -am } else { 0 }; fdiv(xi * ALVL * 2 + sign, 2 * am) as i64 }).collect();
+    (q, scale_from(am, cur))
+}
+fn fnv(bytes: &[u8]) -> u64 { let mut h = 0xcbf29ce484222325u64; for &b in bytes { h ^= b as u64; h = h.wrapping_mul(0x100000001b3); } h }
+
+struct Cur<'a> { b: &'a [u8], p: usize }
+impl<'a> Cur<'a> {
+    fn u8(&mut self) -> u8 { let v = self.b[self.p]; self.p += 1; v }
+    fn u32(&mut self) -> u32 { let v = u32::from_le_bytes(self.b[self.p..self.p + 4].try_into().unwrap()); self.p += 4; v }
+    fn i32(&mut self) -> i32 { let v = i32::from_le_bytes(self.b[self.p..self.p + 4].try_into().unwrap()); self.p += 4; v }
+    fn i64(&mut self) -> i64 { let v = i64::from_le_bytes(self.b[self.p..self.p + 8].try_into().unwrap()); self.p += 8; v }
+}
+// W2d: int8 weights [rows*cols] + per-row Q30 scale.  V1d: int32 [n] + single Q30 scale.
+struct W2d { rows: usize, cols: usize, w: Vec<i8>, sq: Vec<i128> }
+struct V1d { v: Vec<i64>, sq: i128 }
+fn rd_w2d(c: &mut Cur) -> W2d {
+    assert_eq!(c.u8(), 0); let rows = c.u32() as usize; let cols = c.u32() as usize;
+    let w: Vec<i8> = (0..rows * cols).map(|_| c.u8() as i8).collect();
+    let ns = c.u32() as usize; let sq = (0..ns).map(|_| { let m0 = c.i32() as i64; let sh = c.i32() as i64; qm(m0, sh) }).collect();
+    W2d { rows, cols, w, sq }
+}
+fn rd_v1d(c: &mut Cur) -> V1d {
+    assert_eq!(c.u8(), 1); let n = c.u32() as usize; let _cols = c.u32();
+    let v: Vec<i64> = (0..n).map(|_| c.i32() as i64).collect();
+    let _ns = c.u32(); let m0 = c.i32() as i64; let sh = c.i32() as i64;
+    V1d { v, sq: qm(m0, sh) }
+}
+
+fn proj(w: &W2d, b: &V1d, xn_q: &[i64], xn_sq: i128) -> (Vec<i64>, i128) {
+    let (oc, inn) = (w.rows, w.cols);
+    let mut acc = vec![0i64; S * oc];
+    for s in 0..S { for o in 0..oc { let mut a = 0i64; for d in 0..inn { a += xn_q[s * inn + d] * (w.w[o * inn + d] as i64); } acc[s * oc + o] = a; } }
+    let colsq: Vec<i128> = (0..oc).map(|o| mul(xn_sq, w.sq[o])).collect();
+    let bacc: Vec<i64> = (0..oc).map(|o| { let cs = colsq[o]; if cs == 0 { 0 } else { let num = (b.v[o] as i128) * b.sq * (1i128 << SC) + (cs >> 1); (fdiv(num, cs) >> SC) as i64 } }).collect();
+    let cmax = *colsq.iter().max().unwrap();
+    let ratio: Vec<i128> = (0..oc).map(|o| (colsq[o] << SC) / cmax).collect();
+    let mut resc = vec![0i64; S * oc];
+    for s in 0..S { for o in 0..oc { let ab = (acc[s * oc + o] as i128) + (bacc[o] as i128); resc[s * oc + o] = apply(ab, ratio[o]) as i64; } }
+    aq(&resc, cmax)
+}
+fn rmsnorm(hv: &[i64], gam: &V1d) -> (Vec<i64>, i128) {
+    let mut yg = vec![0i64; S * D];
+    for s in 0..S {
+        let ss: i128 = (0..D).map(|d| { let x = hv[s * D + d] as i128; x * x }).sum();
+        let mean = ss / (D as i128) + 1;
+        let inv = isqrt((1i128 << 40) / mean) as i64;
+        for d in 0..D { yg[s * D + d] = hv[s * D + d] * inv * gam.v[d]; }
+    }
+    let (q, s0) = aq(&yg, 1i128 << SC);
+    (q, mul(mul(s0, qm(1, 11)), gam.sq))
+}
+fn proj_nb(w: &W2d, xn_q: &[i64], xn_sq: i128) -> (Vec<i64>, i128) { // W8A16 GEMM, no bias
+    let (oc, inn) = (w.rows, w.cols);
+    let mut acc = vec![0i64; S * oc];
+    for s in 0..S { for o in 0..oc { let mut a = 0i64; for d in 0..inn { a += xn_q[s * inn + d] * (w.w[o * inn + d] as i64); } acc[s * oc + o] = a; } }
+    let colsq: Vec<i128> = (0..oc).map(|o| mul(xn_sq, w.sq[o])).collect();
+    let cmax = *colsq.iter().max().unwrap();
+    let ratio: Vec<i128> = (0..oc).map(|o| (colsq[o] << SC) / cmax).collect();
+    let mut resc = vec![0i64; S * oc];
+    for s in 0..S { for o in 0..oc { resc[s * oc + o] = apply(acc[s * oc + o] as i128, ratio[o]) as i64; } }
+    aq(&resc, cmax)
+}
+fn rope(x: &mut [i64], nh: usize, cosq: &[i64], sinq: &[i64]) {
+    let src = x.to_vec();
+    for s in 0..S { for h in 0..nh { for d in 0..HD {
+        let base = (s * nh + h) * HD;
+        let rh = if d < HD / 2 { -src[base + d + HD / 2] } else { src[base + d - HD / 2] };
+        x[base + d] = (src[base + d] * cosq[s * HD + d] + rh * sinq[s * HD + d] + 16384) >> 15;
+    } } }
+}
+
+fn main() {
+    let path = std::env::args().nth(1).unwrap_or("layer0.bin".into());
+    let mut buf = Vec::new(); std::fs::File::open(&path).unwrap().read_to_end(&mut buf).unwrap();
+    assert_eq!(&buf[0..8], b"L0BIN\0\0\0");
+    let mut c = Cur { b: &buf, p: 8 };
+    let gam = rd_v1d(&mut c);
+    let qw = rd_w2d(&mut c); let qb = rd_v1d(&mut c);
+    let kw = rd_w2d(&mut c); let kb = rd_v1d(&mut c);
+    let vw = rd_w2d(&mut c); let vb = rd_v1d(&mut c);
+    let ow = rd_w2d(&mut c);
+    let xt = rd_w2d(&mut c); // X: [S, D] int8 + per-row scale
+    let pan = rd_v1d(&mut c); // post_attention_layernorm
+    let gw = rd_w2d(&mut c); let uw = rd_w2d(&mut c); let dw = rd_w2d(&mut c); // mlp gate/up/down
+    let cosq: Vec<i64> = (0..S * HD).map(|_| c.i64()).collect();
+    let sinq: Vec<i64> = (0..S * HD).map(|_| c.i64()).collect();
+    let exp: Vec<i64> = (0..256).map(|_| c.i64()).collect();
+    let sig: Vec<i64> = (0..4096).map(|_| c.i64()).collect();
+
+    let xv: Vec<i64> = xt.w.iter().map(|&x| x as i64).collect(); // [S*D]
+    let xsq: Vec<i128> = xt.sq.clone();                          // [S] per-token
+
+    let (xn_q, xn_sq) = rmsnorm(&xv, &gam);
+
+    let (mut qq, qsq) = proj(&qw, &qb, &xn_q, xn_sq); // [S*NH*HD]
+    let (mut kq, ksq) = proj(&kw, &kb, &xn_q, xn_sq); // [S*NKV*HD]
+    let (vq, vsq) = proj(&vw, &vb, &xn_q, xn_sq);
+    rope(&mut qq, NH, &cosq, &sinq);
+    rope(&mut kq, NKV, &cosq, &sinq);
+
+    // scores[h][s][t] = sum_d qq[s,h,d]*kq[t,kvh,d]
+    let g = NH / NKV;
+    let mut scores = vec![0i64; NH * S * S];
+    for h in 0..NH { let kvh = h / g; for s in 0..S { for t in 0..S {
+        let mut a = 0i64; for d in 0..HD { a += qq[(s * NH + h) * HD + d] * kq[(t * NKV + kvh) * HD + d]; }
+        scores[(h * S + s) * S + t] = a;
+    } } }
+    let c8 = mul(qsq, ksq) * 8;
+    let mut pn = vec![0i64; NH * S * S]; let mut ps = vec![0i64; NH * S];
+    for h in 0..NH { for s in 0..S {
+        let mut m = i64::MIN; for t in 0..=s { m = m.max(scores[(h * S + s) * S + t]); }
+        let mut sm = 0i64;
+        for t in 0..=s {
+            let mut dd = apply((m - scores[(h * S + s) * S + t]) as i128, c8);
+            if dd < 0 { dd = 0; } if dd > 255 { dd = 255; }
+            let e = exp[dd as usize]; pn[(h * S + s) * S + t] = e; sm += e;
+        }
+        ps[h * S + s] = sm;
+    } }
+    // A.V -> attn[s][h*HD+d]
+    let mut attn = vec![0i64; S * D];
+    for h in 0..NH { let kvh = h / g; for s in 0..S {
+        let den = ps[h * S + s] as i128;
+        for d in 0..HD {
+            let mut acc = 0i128; for t in 0..=s { acc += (pn[(h * S + s) * S + t] as i128) * (vq[(t * NKV + kvh) * HD + d] as i128); }
+            attn[s * D + h * HD + d] = (fdiv(acc * (1i128 << SC) + (den >> 1), den) >> SC) as i64;
+        }
+    } }
+    let (aq_attn, aq_attn_sq) = aq(&attn, vsq);
+    // o_proj + residual
+    let mut oacc = vec![0i64; S * D];
+    for s in 0..S { for d2 in 0..D { let mut a = 0i64; for d in 0..D { a += aq_attn[s * D + d] * (ow.w[d2 * D + d] as i64); } oacc[s * D + d2] = a; } }
+    let ocsq: Vec<i128> = (0..D).map(|d2| mul(aq_attn_sq, ow.sq[d2])).collect();
+    let mut hout = vec![0i64; S * D];
+    for s in 0..S { let xs = xsq[s]; for d2 in 0..D { let ratio = (ocsq[d2] << SC) / xs; hout[s * D + d2] = xv[s * D + d2] + apply(oacc[s * D + d2] as i128, ratio) as i64; } }
+
+    // ---- SwiGLU MLP sub-block (4b-3) ----
+    let (xn2_q, xn2_sq) = rmsnorm(&hout, &pan);
+    let (gate_q, gate_sq) = proj_nb(&gw, &xn2_q, xn2_sq); // [S*FF]
+    let (up_q, up_sq) = proj_nb(&uw, &xn2_q, xn2_sq);
+    let ff = gw.rows;
+    let mut act_int = vec![0i64; S * ff];
+    for i in 0..S * ff { let mut idx = apply(gate_q[i] as i128, gate_sq << 7) + 2048; if idx < 0 { idx = 0; } if idx > 4095 { idx = 4095; } act_int[i] = gate_q[i] * sig[idx as usize]; }
+    let (act_q, spre) = aq(&act_int, gate_sq); let act_sq = spre >> 16;
+    let mut hmul = vec![0i64; S * ff];
+    for i in 0..S * ff { hmul[i] = act_q[i] * up_q[i]; }
+    let hmul_sq = mul(act_sq, up_sq);
+    let (hmul_q, hmul_q_sq) = aq(&hmul, hmul_sq);
+    let (mlp_q, mlp_sq) = proj_nb(&dw, &hmul_q, hmul_q_sq); // [S*D]
+    let mut layer = vec![0i64; S * D];
+    for s in 0..S { let ratio = (mlp_sq << SC) / xsq[s]; for d2 in 0..D { layer[s * D + d2] = hout[s * D + d2] + apply(mlp_q[s * D + d2] as i128, ratio) as i64; } }
+
+    let bytes: Vec<u8> = layer.iter().flat_map(|v| v.to_le_bytes()).collect();
+    let fp = fnv(&bytes);
+    println!("backend      = Rust CPU ({})", std::env::consts::ARCH);
+    println!("layer-out FNV= {:016x}", fp);
+    println!("TARGET       = {:016x}", TARGET);
+    println!("MATCH        = {}", if fp == TARGET { "YES (byte-identical to Python integer reference)" } else { "NO" });
+    println!("layer[0..4]  = {:?}", &layer[0..4]);
+    let _ = hmul_q_sq;
+}
diff --git a/docs/evidence/canon_attn_int.py b/docs/evidence/canon_attn_int.py
new file mode 100644
index 0000000000000000000000000000000000000000..26786b8f89b5e258dad8f370f331d359196363e0
--- /dev/null
+++ b/docs/evidence/canon_attn_int.py
@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+# inc4b-2b reference: FULLY-INTEGER attention block (Qwen2.5-0.5B layer 0). No fp on the compute path —
+# all scales are Q30 fixed-point integers. This is the exact spec + target fingerprint the Rust/Metal/CUDA
+# ports must reproduce byte-for-byte. Also checks accuracy is preserved (~2.6% vs fp) and prints an FNV over
+# the integer block output.
+import sys, json, struct, numpy as np
+CANON = sys.argv[1] if len(sys.argv) > 1 else "/root/models/qwen05.canon"
+D, NH, NKV, HD, THETA, S = 896, 14, 2, 64, 1000000.0, 4
+ALVL = 32767            # int16 activations (W8A16)
+SC = 30                 # scale fixed-point bits (Q30)
+HALF = 1 << (SC - 1)
+
+def read_canon(path):
+    f = open(path, "rb"); assert f.read(8) == b"CANONv1\n"
+    n = struct.unpack("<Q", f.read(8))[0]; hdr = json.loads(f.read(n)); body = f.read(); out = {}
+    for t in hdr["tensors"]:
+        nm, k, shp = t["name"], t["kind"], t["shape"]
+        if k == "w2d_int8_pcs":
+            o, i = shp
+            w = np.frombuffer(body[t["w_off"]:t["w_off"]+o*i], np.int8).reshape(o, i).astype(np.int64)
+            sc = np.frombuffer(body[t["s_off"]:t["s_off"]+o*8], np.int32).reshape(o, 2)
+            sq = np.array([qm_from_fixed(int(a), int(b)) for a, b in sc], np.int64)  # per-out-ch scale in Q30
+            out[nm] = ("w", w, sq)
+        else:
+            v = np.frombuffer(body[t["w_off"]:t["w_off"]+shp[0]*4], np.int32).astype(np.int64)
+            m0, sh = struct.unpack("<ii", body[t["s_off"]:t["s_off"]+8])
+            out[nm] = ("v", v, qm_from_fixed(m0, sh))
+    return out
+
+def qm_from_fixed(m0, shift):   # gemmlowp (m0, shift) -> Q30 integer scale = round(m0*2^(shift-31) * 2^30)
+    e = shift - 1                # scale = m0 * 2^(shift-31); *2^30 => m0 * 2^(shift-1)
+    if e >= 0: return (m0 << e)
+    return (m0 + (1 << (-e - 1))) >> (-e)  # round
+def apply(acc, sq):  return (acc * sq + HALF) >> SC          # round(acc * scale)
+def mul(a, b):       return (a * b + HALF) >> SC             # Q30 * Q30 -> Q30
+def scale_from(amax, cur_sq): return (amax * cur_sq) // ALVL # new abs scale after requant to ALVL levels
+def aq(v, cur_sq):   # v: int64 array, cur_sq: Q30 abs scale -> (q int64 in +-ALVL, new_sq Q30)
+    amax = int(np.max(np.abs(v))) or 1
+    q = (v * ALVL * 2 + np.sign(v) * amax) // (2 * amax)
+    return q.astype(np.int64), scale_from(amax, cur_sq)
+
+# RoPE Q15 tables (offline)
+inv_freq = 1.0/(THETA**(np.arange(0, HD, 2)/HD)); ang = np.outer(np.arange(S), inv_freq)
+cosF = np.concatenate([np.cos(ang)]*2, 1); sinF = np.concatenate([np.sin(ang)]*2, 1)
+cosQ = np.clip(np.rint(cosF*32768), -32768, 32767).astype(np.int64); sinQ = np.clip(np.rint(sinF*32768), -32768, 32767).astype(np.int64)
+def rope_int(xq):
+    rh = np.concatenate([-xq[..., HD//2:], xq[..., :HD//2]], -1)
+    return (xq*cosQ[:, None, :] + rh*sinQ[:, None, :] + 16384) >> 15     # scale preserved
+def build_exp(n=28):
+    ONE = 1 << 16; t = np.zeros(256, np.int64)
+    for d in range(256):
+        x = -d*(ONE//64); e = ONE; k = n
+        while k >= 1: e = ONE+((x*e)//ONE)//k; k -= 1
+        t[d] = max(0, e)
+    return t
+EXP = build_exp()
+def fnv(b):
+    h = 0xcbf29ce484222325
+    for x in b: h = ((h ^ (x & 0xff)) * 0x100000001b3) & 0xFFFFFFFFFFFFFFFF
+    return h
+
+T = read_canon(CANON)
+L = "model.layers.0."
+Wemb, Wemb_sq = T["model.embed_tokens.weight"][1], T["model.embed_tokens.weight"][2]
+ids = [9707, 11, 1879, 30][:S]
+# input residual stream: int8 embed values + per-token Q30 scale
+Xv = np.stack([Wemb[i] for i in ids]).astype(np.int64)      # [S,D] int8 values
+Xsq = np.array([Wemb_sq[i] for i in ids], np.int64)         # [S] Q30
+
+def imm(a, w): return a @ w.T                                # int64 matmul
+
+# ---- fully-integer block ----
+# RMSNorm on Xv (scale-invariant): normalize then *gamma; keep Q20 precision
+gW = T[L+"input_layernorm.weight"]                           # ("v", vint, sq)
+gam_v, gam_sq = gW[1], gW[2]
+def isqrt(n):                                               # integer floor sqrt (Newton) — fp-free
+    if n <= 0: return 0
+    x = int(n); y = (x + 1) // 2
+    while y < x: x = y; y = (x + int(n) // x) // 2
+    return x
+ss = np.sum(Xv**2, 1); mean = ss//D + 1
+inv = np.array([isqrt((1 << 40)//int(m)) for m in mean], np.int64)  # ~2^20/sqrt(mean), integer
+ynorm = Xv * inv[:, None]                                    # normalize(Xv) in Q20
+yg = ynorm * gam_v[None, :]                                  # * gamma_int (gamma true = gam_v*gam_sq)
+# yg true scale = 2^-20 (from ynorm Q20) * gam_sq ; quantize yg to int16
+xn_q, xn_sq0 = aq(yg, 1 << SC)                               # treat yg as raw ints, scale rel to yg units
+# fold in the true unit scale of yg: true_rms_out = yg * 2^-20 * gam_sq -> multiply xn scale
+xn_sq = mul(mul(xn_sq0, qm_from_fixed(1, 31 - 20)), gam_sq)  # * 2^-20 * gam_sq  (2^-20 as (m0=1<<30,shift=31-20))
+
+def proj(wname, bname):
+    _, wv, wsq = T[wname]; acc = imm(xn_q, wv)               # [S,out] int
+    bv, bsq = T[bname][1], T[bname][2]
+    out = np.zeros_like(acc)
+    for o in range(acc.shape[1]):
+        os = mul(xn_sq, int(wsq[o]))                         # acc scale = xn_sq*wsq[o]
+        # bias true = bv[o]*bsq ; in acc-scale units: bacc = round(bv[o]*bsq / os)
+        bacc = (int(bv[o]) * bsq * (1 << SC) + (os >> 1)) // os >> SC if os else 0
+        out[:, o] = acc[:, o] + bacc
+        out_sq_o = os
+    # per-channel scale differs; requant each column to a common int16 rep with per-tensor scale
+    # true[s,o] = out[s,o]*os[o]; dequant to compare -> but for downstream keep as (values, per-col scale)
+    return acc, wsq, np.array([mul(xn_sq, int(wsq[o])) for o in range(acc.shape[1])], np.int64), bv, bsq
+
+# NOTE: projection produces per-output-channel scales; fold into a single int16 tensor for attention below.
+def proj_i16(wname, bname, nheads):
+    _, wv, wsq = T[wname]; acc = imm(xn_q, wv)               # [S,out] int64
+    bv, bsq = T[bname][1], int(T[bname][2])
+    OUT = acc.shape[1]
+    colsq = [mul(int(xn_sq), int(wsq[o])) for o in range(OUT)]              # per-col Q30 (python ints)
+    bacc = [(((int(bv[o])*bsq*(1 << SC) + (cs >> 1)) // cs) >> SC) if (cs := colsq[o]) else 0
+            for o in range(OUT)]
+    accb = acc + np.array(bacc, np.int64)[None, :]
+    cmax = max(colsq)
+    rescaled = np.empty_like(acc)
+    for o in range(OUT):
+        rescaled[:, o] = apply(accb[:, o], (colsq[o] << SC) // cmax)        # -> common scale cmax
+    q, sq = aq(rescaled.reshape(-1), cmax); q = q.reshape(acc.shape)
+    return q.reshape(S, nheads, HD), sq
+
+qq, qsq = proj_i16(L+"self_attn.q_proj.weight", L+"self_attn.q_proj.bias", NH)
+kq, ksq = proj_i16(L+"self_attn.k_proj.weight", L+"self_attn.k_proj.bias", NKV)
+vq, vsq = proj_i16(L+"self_attn.v_proj.weight", L+"self_attn.v_proj.bias", NKV)
+qq, kq = rope_int(qq), rope_int(kq)
+kq14 = np.repeat(kq, NH//NKV, 1); vq14 = np.repeat(vq, NH//NKV, 1)
+scores = np.einsum('shd,thd->hst', qq, kq14)                 # int
+Csq = mul(qsq, ksq)                                          # q*k scale; /sqrt(HD)=/8 -> >>3 on the value
+# softmax: d = round((m-row) * Csq/8 * 64) = apply((m-row), Csq)*8  (Csq*64/8=Csq*8)
+C8 = Csq * 8
+probs_num = np.zeros((NH, S, S), np.int64); psum = np.zeros((NH, S), np.int64)
+for h in range(NH):
+    for s in range(S):
+        row = scores[h, s, :s+1]; m = int(row.max())
+        d = np.clip([apply(m - int(r), C8) for r in row], 0, 255)
+        e = EXP[np.array(d)]; probs_num[h, s, :s+1] = e; psum[h, s] = int(e.sum())
+# A.V in integer: out[s,h,dd] = sum_t probs[h,s,t]*v[t,h,dd] ; probs = num/psum (Q16-ish via e)
+attn = np.zeros((S, NH, HD), np.int64)
+for h in range(NH):
+    for s in range(S):
+        num = probs_num[h, s, :s+1]; den = int(psum[h, s])
+        acc = np.sum(num[:, None] * vq14[:s+1, h, :], 0)     # int
+        attn[s, h, :] = (acc * (1 << SC) + (den >> 1)) // den >> SC  # /den, keep vq scale
+attn = attn.reshape(S, D); attn_sq = vsq
+aq_attn, aq_attn_sq = aq(attn.reshape(-1), attn_sq); aq_attn = aq_attn.reshape(S, D)
+_, wo, wosq = T[L+"self_attn.o_proj.weight"]
+oacc = imm(aq_attn, wo)                                       # [S,D]
+o_colsq = [mul(int(aq_attn_sq), int(wosq[o])) for o in range(D)]   # per-col Q30, python ints
+# residual h_out[s,d] true = Xv[s,d]*Xsq[s] + oacc[s,d]*o_colsq[d] ; bring o into the X (per-token) scale
+hout = np.zeros((S, D), np.int64)
+for s in range(D and S):
+    xs = int(Xsq[s])
+    ratio = [(o_colsq[d] << SC) // xs for d in range(D)]      # o_colsq[d]/Xsq[s] in Q30
+    o_in_x = np.array([apply(int(oacc[s, d]), ratio[d]) for d in range(D)], np.int64)
+    hout[s] = Xv[s] + o_in_x
+# fingerprint over the integer block output
+b = hout.astype(np.int64).tobytes()
+fp = fnv(b)
+
+# accuracy vs fp reference (dequant hout to fp using Xsq)
+hout_fp_est = hout.astype(np.float64) * (Xsq[:, None].astype(np.float64) / (1 << SC))
+# full fp reference
+wd = lambda n: T[n][1].astype(np.float64) * np.array([T[n][2][o]/(1 << SC) for o in range(T[n][1].shape[0])])[:, None]
+vd = lambda n: T[n][1].astype(np.float64) * (T[n][2]/(1 << SC))
+Wq, Wk, Wv, Wo = wd(L+"self_attn.q_proj.weight"), wd(L+"self_attn.k_proj.weight"), wd(L+"self_attn.v_proj.weight"), wd(L+"self_attn.o_proj.weight")
+bq, bk, bv = vd(L+"self_attn.q_proj.bias"), vd(L+"self_attn.k_proj.bias"), vd(L+"self_attn.v_proj.bias")
+gin = vd(L+"input_layernorm.weight")
+Xfp = Xv.astype(np.float64) * (Xsq[:, None].astype(np.float64)/(1 << SC))
+xn = Xfp/np.sqrt(np.mean(Xfp**2, 1, keepdims=True)+1e-6)*gin
+q = (xn@Wq.T+bq).reshape(S, NH, HD); k = (xn@Wk.T+bk).reshape(S, NKV, HD); v = (xn@Wv.T+bv).reshape(S, NKV, HD)
+rhf = lambda x: np.concatenate([-x[..., HD//2:], x[..., :HD//2]], -1)
+q = q*cosF[:, None, :]+rhf(q)*sinF[:, None, :]; k = k*cosF[:, None, :]+rhf(k)*sinF[:, None, :]
+k14 = np.repeat(k, NH//NKV, 1); v14 = np.repeat(v, NH//NKV, 1)
+scf = np.einsum('shd,thd->hst', q, k14)/np.sqrt(HD)
+for h in range(NH):
+    for s in range(S): scf[h, s, s+1:] = -1e30
+af = np.zeros((S, NH, HD))
+for h in range(NH):
+    p = np.exp(scf[h]-scf[h].max(1, keepdims=True)); p /= p.sum(1, keepdims=True); af[:, h, :] = p@v14[:, h, :]
+o_fp = af.reshape(S, D)@Wo.T; hfp = Xfp + o_fp
+rel = float(np.sqrt(np.sum((hout_fp_est-hfp)**2)/np.sum(hfp**2)))
+print(f"fully-integer block: accuracy vs fp = {rel:.4f}")
+print(f"block-output FNV = {fp:016x}   <- Rust/Metal/CUDA ports must reproduce")
+print(f"hout[0,:4] int = {hout[0,:4]}")
diff --git a/docs/evidence/canon_attn_norm.rs b/docs/evidence/canon_attn_norm.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4539e0ca164dddd60a73bd26631685c0d0a1a86f
--- /dev/null
+++ b/docs/evidence/canon_attn_norm.rs
@@ -0,0 +1,233 @@
+// Metal-profile integer layer (design §8): normalized (m0,e) scales, ALL arithmetic i64 + explicit
+// two-word (hi,lo) 64x64 multiply + shift — every op maps 1:1 onto MSL (metal::mulhi(long)).
+// This profile has its OWN reference fingerprint (rounding positions differ from the Q30/Q60 profiles);
+// the claim is cross-backend identity: Rust-x86 == Rust-aarch64 == Metal-GPU.
+// Build/run: rustc -O --edition 2021 canon_attn_norm.rs -o canon_attn_norm && ./canon_attn_norm layer0.bin
+
+use std::io::Read;
+
+const ALVL: i64 = 32767; // A16 for the layer profile (matches layer0.bin block config)
+const D: usize = 896;
+const NH: usize = 14;
+const NKV: usize = 2;
+const HD: usize = 64;
+const S: usize = 4;
+
+// ---- normalized scale: value = m0 * 2^e, m0 in [2^30, 2^31) (or m0=0) ----
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct Sc { m0: i64, e: i32 }
+
+fn norm(mut m0: i64, mut e: i32) -> Sc {
+    if m0 <= 0 { return Sc { m0: 0, e: 0 }; }
+    while m0 >= 1 << 31 { m0 = (m0 + 1) >> 1; e += 1; }
+    while m0 < 1 << 30 { m0 <<= 1; e -= 1; }
+    Sc { m0, e }
+}
+fn sc_from_int(x: i64) -> Sc { norm(x, 0) }                       // integer as scale
+fn sc_from_fixed(m0: i64, sh: i64) -> Sc { norm(m0, (sh - 31) as i32) } // gemmlowp (m0,shift)
+fn sc_mul(a: Sc, b: Sc) -> Sc {
+    if a.m0 == 0 || b.m0 == 0 { return Sc { m0: 0, e: 0 }; }
+    let p = a.m0 * b.m0;                                          // < 2^62, fits i64
+    norm((p + (1 << 30)) >> 31, a.e + b.e + 31)
+}
+fn sc_ratio(a: Sc, b: Sc) -> Sc {
+    if a.m0 == 0 { return Sc { m0: 0, e: 0 }; }
+    norm((a.m0 << 31) / b.m0, a.e - b.e - 31)                     // a.m0<<31 < 2^62
+}
+fn sc_cmp(a: Sc, b: Sc) -> std::cmp::Ordering {                   // compare a vs b (values)
+    if a.m0 == 0 || b.m0 == 0 { return a.m0.cmp(&b.m0); }
+    if a.e != b.e { return a.e.cmp(&b.e); }
+    a.m0.cmp(&b.m0)
+}
+
+// ---- two-word 64x64 multiply + shift (the exact ops MSL provides: mulhi + mullo) ----
+fn mul64_wide(a: u64, b: u64) -> (u64, u64) {
+    // (hi, lo) of a*b — expressed via 32-bit limbs so the MSL translation is verbatim
+    let (a0, a1) = (a & 0xFFFF_FFFF, a >> 32);
+    let (b0, b1) = (b & 0xFFFF_FFFF, b >> 32);
+    let p00 = a0 * b0;
+    let p01 = a0 * b1;
+    let p10 = a1 * b0;
+    let p11 = a1 * b1;
+    let mid = (p00 >> 32) + (p01 & 0xFFFF_FFFF) + (p10 & 0xFFFF_FFFF);
+    let lo = (p00 & 0xFFFF_FFFF) | (mid << 32);
+    let hi = p11 + (p01 >> 32) + (p10 >> 32) + (mid >> 32);
+    (hi, lo)
+}
+/// round(v * m0 * 2^e), round-half-away-from-zero. |v| < 2^62; result must fit i64.
+fn apply_sc(v: i64, s: Sc) -> i64 {
+    if s.m0 == 0 || v == 0 { return 0; }
+    let neg = v < 0;
+    let av = v.unsigned_abs();
+    let (hi, lo) = mul64_wide(av, s.m0 as u64);
+    let k = -(s.e);                                               // shift right by k (e<0 in practice)
+    let mag: u64 = if s.e >= 0 {
+        assert!(hi == 0 && lo.leading_zeros() as i32 > s.e, "apply_sc overflow");
+        lo << s.e
+    } else if k >= 128 {
+        0
+    } else if k >= 64 {
+        let kk = k - 64;
+        let main = if kk == 0 { hi } else { hi >> kk };
+        let rbit = if kk == 0 { (lo >> 63) & 1 } else { (hi >> (kk - 1)) & 1 };
+        main + rbit
+    } else {
+        let main = (hi << (64 - k)) | (lo >> k);
+        let rbit = (lo >> (k - 1)) & 1;
+        main + rbit
+    };
+    let m = mag as i64;
+    if neg { -m } else { m }
+}
+/// materialize a scale product as an integer: round(m0 * 2^e)
+fn sc_to_int(s: Sc) -> i64 { apply_sc(1, Sc { m0: s.m0, e: s.e }) }
+
+fn fnv(bytes: &[u8]) -> u64 { let mut h = 0xcbf29ce484222325u64; for &b in bytes { h ^= b as u64; h = h.wrapping_mul(0x100000001b3); } h }
+fn isqrt64(n: i64) -> i64 { if n <= 0 { return 0; } let mut x = n; let mut y = (x + 1) / 2; while y < x { x = y; y = (x + n / x) / 2; } x }
+
+// ---- layer0.bin records (same format as canon_attn.rs) ----
+struct Cur<'a> { b: &'a [u8], p: usize }
+impl<'a> Cur<'a> {
+    fn u8(&mut self) -> u8 { let v = self.b[self.p]; self.p += 1; v }
+    fn u32(&mut self) -> u32 { let v = u32::from_le_bytes(self.b[self.p..self.p + 4].try_into().unwrap()); self.p += 4; v }
+    fn i32(&mut self) -> i32 { let v = i32::from_le_bytes(self.b[self.p..self.p + 4].try_into().unwrap()); self.p += 4; v }
+    fn i64v(&mut self) -> i64 { let v = i64::from_le_bytes(self.b[self.p..self.p + 8].try_into().unwrap()); self.p += 8; v }
+}
+struct W2d { rows: usize, cols: usize, w: Vec<i8>, sq: Vec<Sc> }
+struct V1d { v: Vec<i64>, sq: Sc }
+fn rd_w2d(c: &mut Cur) -> W2d {
+    assert_eq!(c.u8(), 0); let rows = c.u32() as usize; let cols = c.u32() as usize;
+    let w: Vec<i8> = (0..rows * cols).map(|_| c.u8() as i8).collect();
+    let ns = c.u32() as usize;
+    let sq = (0..ns).map(|_| { let m0 = c.i32() as i64; let sh = c.i32() as i64; sc_from_fixed(m0, sh) }).collect();
+    W2d { rows, cols, w, sq }
+}
+fn rd_v1d(c: &mut Cur) -> V1d {
+    assert_eq!(c.u8(), 1); let n = c.u32() as usize; let _ = c.u32();
+    let v: Vec<i64> = (0..n).map(|_| c.i32() as i64).collect();
+    let _ = c.u32(); let m0 = c.i32() as i64; let sh = c.i32() as i64;
+    V1d { v, sq: sc_from_fixed(m0, sh) }
+}
+
+fn aq(v: &[i64], cur: Sc) -> (Vec<i64>, Sc) {
+    let am = v.iter().map(|x| x.abs()).max().unwrap().max(1);
+    let q = v.iter().map(|&x| {
+        let neg = x < 0; let ax = x.abs();
+        // round(ax*ALVL/am), half away from zero: (2*ax*ALVL + am) / (2*am)  — ax<2^42*? keep safe:
+        // ax can reach ~2^42 (yg); ax*ALVL*2 ~ 2^58 fits i64.
+        let q = (2 * ax * ALVL + am) / (2 * am);
+        if neg { -q } else { q }
+    }).collect();
+    (q, sc_mul(sc_from_int(am), sc_ratio(cur, sc_from_int(ALVL))))
+}
+
+fn rmsnorm(hv: &[i64], gam: &V1d) -> (Vec<i64>, Sc) {
+    let mut yg = vec![0i64; S * D];
+    for s in 0..S {
+        let ss: i64 = (0..D).map(|d| { let x = hv[s * D + d]; x * x }).sum(); // |hv|<2^12 → ss<2^34
+        let mean = ss / (D as i64) + 1;
+        let inv = isqrt64((1i64 << 40) / mean);
+        for d in 0..D { yg[s * D + d] = hv[s * D + d] * inv * gam.v[d]; }
+    }
+    let (q, s0) = aq(&yg, Sc { m0: 1 << 30, e: -30 }); // cur = 1.0
+    // * 2^-20 (Q20 norm) * gamma scale
+    (q, sc_mul(sc_mul(s0, Sc { m0: 1 << 30, e: -50 }), gam.sq))
+}
+fn proj(w: &W2d, b: Option<&V1d>, xn_q: &[i64], xn_sq: Sc) -> (Vec<i64>, Sc) {
+    let (oc, inn) = (w.rows, w.cols);
+    let mut acc = vec![0i64; S * oc];
+    for s in 0..S { for o in 0..oc { let mut a = 0i64; for d in 0..inn { a += xn_q[s * inn + d] * (w.w[o * inn + d] as i64); } acc[s * oc + o] = a; } }
+    let colsq: Vec<Sc> = (0..oc).map(|o| sc_mul(xn_sq, w.sq[o])).collect();
+    let cmax = *colsq.iter().max_by(|a, b| sc_cmp(**a, **b)).unwrap();
+    let mut resc = vec![0i64; S * oc];
+    for o in 0..oc {
+        let bacc: i64 = match b {
+            Some(bv) if colsq[o].m0 != 0 => sc_to_int(sc_ratio(sc_mul(sc_from_int(bv.v[o]), bv.sq), colsq[o])),
+            _ => 0,
+        };
+        let ratio = sc_ratio(colsq[o], cmax);
+        for s in 0..S { resc[s * oc + o] = apply_sc(acc[s * oc + o] + bacc, ratio); }
+    }
+    aq(&resc, cmax)
+}
+fn rope(x: &mut [i64], nh: usize, cosq: &[i64], sinq: &[i64]) {
+    let src = x.to_vec();
+    for s in 0..S { for h in 0..nh { for d in 0..HD {
+        let base = (s * nh + h) * HD;
+        let rh = if d < HD / 2 { -src[base + d + HD / 2] } else { src[base + d - HD / 2] };
+        x[base + d] = (src[base + d] * cosq[s * HD + d] + rh * sinq[s * HD + d] + 16384) >> 15;
+    } } }
+}
+
+fn main() {
+    let path = std::env::args().nth(1).unwrap_or("layer0.bin".into());
+    let mut buf = Vec::new(); std::fs::File::open(&path).unwrap().read_to_end(&mut buf).unwrap();
+    assert_eq!(&buf[0..8], b"L0BIN\0\0\0");
+    let mut c = Cur { b: &buf, p: 8 };
+    let gam = rd_v1d(&mut c);
+    let qw = rd_w2d(&mut c); let qb = rd_v1d(&mut c);
+    let kw = rd_w2d(&mut c); let kb = rd_v1d(&mut c);
+    let vw = rd_w2d(&mut c); let vb = rd_v1d(&mut c);
+    let ow = rd_w2d(&mut c);
+    let xt = rd_w2d(&mut c);
+    let pan = rd_v1d(&mut c);
+    let gw = rd_w2d(&mut c); let uw = rd_w2d(&mut c); let dw = rd_w2d(&mut c);
+    let cosq: Vec<i64> = (0..S * HD).map(|_| c.i64v()).collect();
+    let sinq: Vec<i64> = (0..S * HD).map(|_| c.i64v()).collect();
+    let exp: Vec<i64> = (0..256).map(|_| c.i64v()).collect();
+    let sig: Vec<i64> = (0..4096).map(|_| c.i64v()).collect();
+
+    let xv: Vec<i64> = xt.w.iter().map(|&x| x as i64).collect();
+    let xsq: Vec<Sc> = xt.sq.clone();
+
+    let (xn_q, xn_sq) = rmsnorm(&xv, &gam);
+    let (mut qq, qsq) = proj(&qw, Some(&qb), &xn_q, xn_sq);
+    let (mut kq, ksq) = proj(&kw, Some(&kb), &xn_q, xn_sq);
+    let (vq, vsq) = proj(&vw, Some(&vb), &xn_q, xn_sq);
+    rope(&mut qq, NH, &cosq, &sinq);
+    rope(&mut kq, NKV, &cosq, &sinq);
+    let g = NH / NKV;
+    // C64 = qsq*ksq*8 (exp-arg 1/64 units, incl 1/sqrt(64)=1/8): e' = e+3
+    let cq = sc_mul(qsq, ksq); let c64 = Sc { m0: cq.m0, e: cq.e + 3 };
+    let mut attn = vec![0i64; S * D];
+    for h in 0..NH { let kvh = h / g; for s in 0..S {
+        let mut scores = vec![0i64; s + 1];
+        for t in 0..=s { let mut a = 0i64; for d in 0..HD { a += qq[(s * NH + h) * HD + d] * kq[(t * NKV + kvh) * HD + d]; } scores[t] = a; }
+        let m = *scores.iter().max().unwrap();
+        let mut e = vec![0i64; s + 1]; let mut den = 0i64;
+        for t in 0..=s { let mut dd = apply_sc(m - scores[t], c64); if dd < 0 { dd = 0; } if dd > 255 { dd = 255; } e[t] = exp[dd as usize]; den += e[t]; }
+        for d in 0..HD {
+            let mut acc = 0i64; for t in 0..=s { acc += e[t] * vq[(t * NKV + kvh) * HD + d]; } // <2^16*2^15*4=2^33
+            attn[s * D + h * HD + d] = { let neg = acc < 0; let a = acc.abs(); let r = (2 * a + den) / (2 * den); if neg { -r } else { r } };
+        }
+    } }
+    let (aqa, aqa_sq) = aq(&attn, vsq);
+    let mut hout = vec![0i64; S * D];
+    for s in 0..S { for d2 in 0..D {
+        let mut a = 0i64; for d in 0..D { a += aqa[s * D + d] * (ow.w[d2 * D + d] as i64); }
+        let ocsq = sc_mul(aqa_sq, ow.sq[d2]);
+        hout[s * D + d2] = xv[s * D + d2] + apply_sc(a, sc_ratio(ocsq, xsq[s]));
+    } }
+    let (xn2_q, xn2_sq) = rmsnorm(&hout, &pan);
+    let (gate_q, gate_sq) = proj(&gw, None, &xn2_q, xn2_sq);
+    let (up_q, up_sq) = proj(&uw, None, &xn2_q, xn2_sq);
+    let ff = gw.rows;
+    let gs9 = Sc { m0: gate_sq.m0, e: gate_sq.e + 9 }; // *512 (idx step 1/... layer profile uses 1/128<<2? keep <<9/8192 domain of 4096-sig? sig table is 4096 @1/128: idx=round(g*128)+2048 → e+7)
+    let gs7 = Sc { m0: gate_sq.m0, e: gate_sq.e + 7 };
+    let _ = gs9;
+    let mut act_int = vec![0i64; S * ff];
+    for i in 0..S * ff { let mut idx = apply_sc(gate_q[i], gs7) + 2048; if idx < 0 { idx = 0; } if idx > 4095 { idx = 4095; } act_int[i] = gate_q[i] * sig[idx as usize]; }
+    let (act_q, spre) = aq(&act_int, gate_sq);
+    let act_sq = Sc { m0: spre.m0, e: spre.e - 16 };            // /2^16 (Q16 sigmoid)
+    let mut hmul = vec![0i64; S * ff];
+    for i in 0..S * ff { hmul[i] = act_q[i] * up_q[i]; }
+    let (hmul_q, hmul_q_sq) = aq(&hmul, sc_mul(act_sq, up_sq));
+    let (mlp_q, mlp_sq) = proj(&dw, None, &hmul_q, hmul_q_sq);
+    let mut layer = vec![0i64; S * D];
+    for s in 0..S { let ratio = sc_ratio(mlp_sq, xsq[s]); for d2 in 0..D { layer[s * D + d2] = hout[s * D + d2] + apply_sc(mlp_q[s * D + d2], ratio); } }
+
+    let bytes: Vec<u8> = layer.iter().flat_map(|v| v.to_le_bytes()).collect();
+    println!("backend      = Rust CPU ({}) [norm (m0,e) profile]", std::env::consts::ARCH);
+    println!("layer FNV    = {:016x}", fnv(&bytes));
+    println!("layer[0..4]  = {:?}  (Q30 profile was [202, 187, 603, -177])", &layer[0..4]);
+}
diff --git a/docs/evidence/canon_attn_norm.swift b/docs/evidence/canon_attn_norm.swift
new file mode 100644
index 0000000000000000000000000000000000000000..37bf0f0e03a104bea1e4da52c7bed387a3f808fb
--- /dev/null
+++ b/docs/evidence/canon_attn_norm.swift
@@ -0,0 +1,334 @@
+// Metal GPU port of the norm-(m0,e) integer layer (design §8). Host parses layer0.bin, converts all
+// stored gemmlowp scales to normalized (m0,e), uploads flat buffers; a single-thread MSL kernel runs the
+// whole layer with ONLY long (i64) ops + a 32-bit-limb two-word multiply — the exact Rust semantics.
+// Must reproduce: layer FNV 50a8caf4107f43f4, layer[0..4] = [265, 210, 581, -123].
+// Build/run: swiftc -O canon_attn_norm.swift -o canon_attn_norm_metal && ./canon_attn_norm_metal layer0.bin
+
+import Foundation
+import Metal
+
+// ---- host-side scale normalization (same as Rust norm/sc_from_fixed) ----
+func normSc(_ m0in: Int64, _ ein: Int32) -> (Int64, Int32) {
+    var m0 = m0in, e = ein
+    if m0 <= 0 { return (0, 0) }
+    while m0 >= (1 << 31) { m0 = (m0 + 1) >> 1; e += 1 }
+    while m0 < (1 << 30) { m0 <<= 1; e -= 1 }
+    return (m0, e)
+}
+
+struct Rd { var d: Data; var p = 0
+    mutating func u8() -> UInt8 { defer { p += 1 }; return d[p] }
+    mutating func u32() -> UInt32 { defer { p += 4 }; return d.subdata(in: p..<p+4).withUnsafeBytes { $0.load(as: UInt32.self) } }
+    mutating func i32() -> Int32 { defer { p += 4 }; return d.subdata(in: p..<p+4).withUnsafeBytes { $0.load(as: Int32.self) } }
+    mutating func i64() -> Int64 { defer { p += 8 }; return d.subdata(in: p..<p+8).withUnsafeBytes { $0.load(as: Int64.self) } }
+}
+struct W2 { var rows = 0, cols = 0; var w: [Int8] = []; var m0: [Int64] = []; var e: [Int32] = [] }
+struct V1 { var v: [Int64] = []; var m0: Int64 = 0; var e: Int32 = 0 }
+func rdW2(_ r: inout Rd) -> W2 {
+    precondition(r.u8() == 0); var t = W2(); t.rows = Int(r.u32()); t.cols = Int(r.u32())
+    t.w = (0..<t.rows*t.cols).map { _ in Int8(bitPattern: r.u8()) }
+    let ns = Int(r.u32())
+    for _ in 0..<ns { let m = Int64(r.i32()); let s = r.i32(); let (m0, e) = normSc(m, s - 31); t.m0.append(m0); t.e.append(e) }
+    return t
+}
+func rdV1(_ r: inout Rd) -> V1 {
+    precondition(r.u8() == 1); var t = V1(); let n = Int(r.u32()); _ = r.u32()
+    t.v = (0..<n).map { _ in Int64(r.i32()) }
+    _ = r.u32(); let m = Int64(r.i32()); let s = r.i32(); (t.m0, t.e) = normSc(m, s - 31)
+    return t
+}
+
+let SHADER = """
+#include <metal_stdlib>
+using namespace metal;
+constant int D = 896, NH = 14, NKV = 2, HD = 64, S = 4, FF = 4864;
+constant long ALVL = 32767;
+
+struct Sc { long m0; int e; };
+static Sc norm_sc(long m0, int e) {
+    Sc s; if (m0 <= 0) { s.m0 = 0; s.e = 0; return s; }
+    while (m0 >= (1L << 31)) { m0 = (m0 + 1) >> 1; e += 1; }
+    while (m0 < (1L << 30)) { m0 <<= 1; e -= 1; }
+    s.m0 = m0; s.e = e; return s;
+}
+static Sc sc_from_int(long x) { return norm_sc(x, 0); }
+static Sc sc_mul(Sc a, Sc b) {
+    if (a.m0 == 0 || b.m0 == 0) { Sc z; z.m0 = 0; z.e = 0; return z; }
+    long p = a.m0 * b.m0;
+    return norm_sc((p + (1L << 30)) >> 31, a.e + b.e + 31);
+}
+static Sc sc_ratio(Sc a, Sc b) {
+    if (a.m0 == 0) { Sc z; z.m0 = 0; z.e = 0; return z; }
+    return norm_sc((a.m0 << 31) / b.m0, a.e - b.e - 31);
+}
+static bool sc_gt(Sc a, Sc b) {   // a > b
+    if (a.m0 == 0 || b.m0 == 0) return a.m0 > b.m0;
+    if (a.e != b.e) return a.e > b.e;
+    return a.m0 > b.m0;
+}
+static void mul64_wide(ulong a, ulong b, thread ulong &hi, thread ulong &lo) {
+    ulong a0 = a & 0xFFFFFFFFUL, a1 = a >> 32;
+    ulong b0 = b & 0xFFFFFFFFUL, b1 = b >> 32;
+    ulong p00 = a0 * b0, p01 = a0 * b1, p10 = a1 * b0, p11 = a1 * b1;
+    ulong mid = (p00 >> 32) + (p01 & 0xFFFFFFFFUL) + (p10 & 0xFFFFFFFFUL);
+    lo = (p00 & 0xFFFFFFFFUL) | (mid << 32);
+    hi = p11 + (p01 >> 32) + (p10 >> 32) + (mid >> 32);
+}
+static long apply_sc(long v, Sc s) {
+    if (s.m0 == 0 || v == 0) return 0;
+    bool neg = v < 0;
+    ulong av = ulong(neg ? -v : v);
+    ulong hi, lo; mul64_wide(av, ulong(s.m0), hi, lo);
+    int k = -s.e;
+    ulong mag;
+    if (s.e >= 0) { mag = lo << s.e; }
+    else if (k >= 128) { mag = 0; }
+    else if (k >= 64) {
+        int kk = k - 64;
+        ulong main_ = (kk == 0) ? hi : (hi >> kk);
+        ulong rbit = (kk == 0) ? ((lo >> 63) & 1) : ((hi >> (kk - 1)) & 1);
+        mag = main_ + rbit;
+    } else {
+        ulong main_ = (hi << (64 - k)) | (lo >> k);
+        ulong rbit = (lo >> (k - 1)) & 1;
+        mag = main_ + rbit;
+    }
+    long m = long(mag);
+    return neg ? -m : m;
+}
+static long sc_to_int(Sc s) { return apply_sc(1, s); }
+static long isqrt64(long n) {
+    if (n <= 0) return 0;
+    long x = n, y = (x + 1) / 2;
+    while (y < x) { x = y; y = (x + n / x) / 2; }
+    return x;
+}
+
+// aq over a span in `vals[off..off+n]`, quantizes in place, returns new scale
+static Sc aq_span(device long* vals, int off, int n, Sc cur) {
+    long am = 1;
+    for (int i = 0; i < n; i++) { long a = vals[off + i]; if (a < 0) a = -a; if (a > am) am = a; }
+    for (int i = 0; i < n; i++) {
+        long x = vals[off + i]; bool neg = x < 0; long ax = neg ? -x : x;
+        long q = (2 * ax * ALVL + am) / (2 * am);
+        vals[off + i] = neg ? -q : q;
+    }
+    return sc_mul(sc_from_int(am), sc_ratio(cur, sc_from_int(ALVL)));
+}
+
+kernel void layer_norm_profile(
+    device const char* qw [[buffer(0)]], device const long* qws [[buffer(1)]],   // scales as (m0,e) pairs: 2*i64 each (e stored as i64)
+    device const char* kw [[buffer(2)]], device const long* kws [[buffer(3)]],
+    device const char* vw [[buffer(4)]], device const long* vws [[buffer(5)]],
+    device const char* ow [[buffer(6)]], device const long* ows [[buffer(7)]],
+    device const char* gw [[buffer(8)]], device const long* gws [[buffer(9)]],
+    device const char* uw [[buffer(10)]], device const long* uws [[buffer(11)]],
+    device const char* dw [[buffer(12)]], device const long* dws [[buffer(13)]],
+    device const long* qb [[buffer(14)]], device const long* kb [[buffer(15)]], device const long* vb [[buffer(16)]],
+    device const long* gamv [[buffer(17)]], device const long* panv [[buffer(18)]],
+    device const char* xv8 [[buffer(19)]], device const long* xscp [[buffer(20)]],
+    device const long* cosq [[buffer(21)]], device const long* sinq [[buffer(22)]],
+    device const long* expl [[buffer(23)]], device const long* sigl [[buffer(24)]],
+    device const long* meta [[buffer(25)]],   // [qb_m0,qb_e, kb_m0,kb_e, vb_m0,vb_e, gam_m0,gam_e, pan_m0,pan_e]
+    device long* scratch [[buffer(26)]],      // big scratch: layout below
+    device long* outbuf [[buffer(27)]],
+    uint gid [[thread_position_in_grid]]) {
+    if (gid != 0) return;
+    // scratch layout (i64 slots):
+    device long* xn  = scratch;                 // S*D
+    device long* qq  = xn + S*D;                // S*NH*HD
+    device long* kq  = qq + S*NH*HD;            // S*NKV*HD
+    device long* vq  = kq + S*NKV*HD;           // S*NKV*HD
+    device long* attn= vq + S*NKV*HD;           // S*D
+    device long* hout= attn + S*D;              // S*D
+    device long* xn2 = hout + S*D;              // S*D
+    device long* gate= xn2 + S*D;               // S*FF
+    device long* up  = gate + S*FF;             // S*FF
+    device long* act = up + S*FF;               // S*FF
+    device long* acc = act + S*FF;              // S*FF (proj scratch)
+    device long* src = acc + S*FF;              // S*NH*HD (rope scratch)
+
+    Sc gamsq; gamsq.m0 = meta[6]; gamsq.e = int(meta[7]);
+    Sc pansq; pansq.m0 = meta[8]; pansq.e = int(meta[9]);
+    Sc qbsq; qbsq.m0 = meta[0]; qbsq.e = int(meta[1]);
+    Sc kbsq; kbsq.m0 = meta[2]; kbsq.e = int(meta[3]);
+    Sc vbsq; vbsq.m0 = meta[4]; vbsq.e = int(meta[5]);
+
+    // ---- rmsnorm(Xv, gamma) -> xn (int16 span) + xnsq ----
+    for (int s = 0; s < S; s++) {
+        long ss = 0;
+        for (int d = 0; d < D; d++) { long x = xv8[s*D + d]; ss += x * x; }
+        long mean = ss / D + 1;
+        long inv = isqrt64((1L << 40) / mean);
+        for (int d = 0; d < D; d++) xn[s*D + d] = long(xv8[s*D + d]) * inv * gamv[d];
+    }
+    Sc one; one.m0 = 1L << 30; one.e = -30;
+    Sc s0 = aq_span(xn, 0, S*D, one);
+    Sc q20; q20.m0 = 1L << 30; q20.e = -50;
+    Sc xnsq = sc_mul(sc_mul(s0, q20), gamsq);
+
+    // ---- proj helper as macro-ish inline (q/k/v with bias, gate/up/down without) ----
+    // computed inline per projection to avoid function-pointer complexity.
+
+#define PROJ(W, WS, OC, BV, BSQ, HAS_B, OUT, OUTSQ, XNBUF, XNSQ) \
+    { \
+        for (int s = 0; s < S; s++) for (int o = 0; o < (OC); o++) { \
+            long a = 0; for (int d = 0; d < D; d++) a += XNBUF[s*D + d] * long(W[o*D + d]); \
+            acc[s*(OC) + o] = a; } \
+        Sc cmax; cmax.m0 = 0; cmax.e = 0; \
+        for (int o = 0; o < (OC); o++) { Sc cs = sc_mul(XNSQ, norm_sc(WS[2*o], int(WS[2*o+1]))); if (sc_gt(cs, cmax)) cmax = cs; } \
+        for (int o = 0; o < (OC); o++) { \
+            Sc cs = sc_mul(XNSQ, norm_sc(WS[2*o], int(WS[2*o+1]))); \
+            long bacc = 0; \
+            if (HAS_B && cs.m0 != 0) bacc = sc_to_int(sc_ratio(sc_mul(sc_from_int(BV[o]), BSQ), cs)); \
+            Sc ratio = sc_ratio(cs, cmax); \
+            for (int s = 0; s < S; s++) OUT[s*(OC) + o] = apply_sc(acc[s*(OC) + o] + bacc, ratio); \
+        } \
+        OUTSQ = aq_span(OUT, 0, S*(OC), cmax); \
+    }
+
+    Sc qsq, ksq, vsq;
+    PROJ(qw, qws, NH*HD, qb, qbsq, true, qq, qsq, xn, xnsq)
+    PROJ(kw, kws, NKV*HD, kb, kbsq, true, kq, ksq, xn, xnsq)
+    PROJ(vw, vws, NKV*HD, vb, vbsq, true, vq, vsq, xn, xnsq)
+
+    // rope on qq (NH) and kq (NKV)
+    for (int pass = 0; pass < 2; pass++) {
+        device long* x = pass == 0 ? qq : kq;
+        int nh = pass == 0 ? NH : NKV;
+        for (int i = 0; i < S*nh*HD; i++) src[i] = x[i];
+        for (int s = 0; s < S; s++) for (int h = 0; h < nh; h++) for (int d = 0; d < HD; d++) {
+            int base = (s*nh + h)*HD;
+            long rh = d < HD/2 ? -src[base + d + HD/2] : src[base + d - HD/2];
+            x[base + d] = (src[base + d] * cosq[s*HD + d] + rh * sinq[s*HD + d] + 16384) >> 15;
+        }
+    }
+    int g = NH / NKV;
+    Sc cq = sc_mul(qsq, ksq); Sc c64; c64.m0 = cq.m0; c64.e = cq.e + 3;
+    for (int h = 0; h < NH; h++) { int kvh = h / g;
+        for (int s = 0; s < S; s++) {
+            long scores[4]; long m = -0x7FFFFFFFFFFFFFFFL;
+            for (int t = 0; t <= s; t++) { long a = 0; for (int d = 0; d < HD; d++) a += qq[(s*NH + h)*HD + d] * kq[(t*NKV + kvh)*HD + d]; scores[t] = a; if (a > m) m = a; }
+            long e[4]; long den = 0;
+            for (int t = 0; t <= s; t++) { long dd = apply_sc(m - scores[t], c64); if (dd < 0) dd = 0; if (dd > 255) dd = 255; e[t] = expl[dd]; den += e[t]; }
+            for (int d = 0; d < HD; d++) {
+                long a = 0; for (int t = 0; t <= s; t++) a += e[t] * vq[(t*NKV + kvh)*HD + d];
+                bool neg = a < 0; long aa = neg ? -a : a; long r = (2*aa + den) / (2*den);
+                attn[s*D + h*HD + d] = neg ? -r : r;
+            }
+        }
+    }
+    Sc aqsq = aq_span(attn, 0, S*D, vsq);
+    for (int s = 0; s < S; s++) for (int d2 = 0; d2 < D; d2++) {
+        long a = 0; for (int d = 0; d < D; d++) a += attn[s*D + d] * long(ow[d2*D + d]);
+        Sc ocs = sc_mul(aqsq, norm_sc(ows[2*d2], int(ows[2*d2+1])));
+        Sc xs; xs.m0 = xscp[2*s]; xs.e = int(xscp[2*s+1]);
+        hout[s*D + d2] = long(xv8[s*D + d2]) + apply_sc(a, sc_ratio(ocs, xs));
+    }
+    // ---- MLP ----
+    for (int s = 0; s < S; s++) {
+        long ss = 0;
+        for (int d = 0; d < D; d++) { long x = hout[s*D + d]; ss += x * x; }
+        long mean = ss / D + 1;
+        long inv = isqrt64((1L << 40) / mean);
+        for (int d = 0; d < D; d++) xn2[s*D + d] = hout[s*D + d] * inv * panv[d];
+    }
+    Sc s02 = aq_span(xn2, 0, S*D, one);
+    Sc xn2sq = sc_mul(sc_mul(s02, q20), pansq);
+
+    Sc gsq, usq;
+    // gate/up proj: OC=FF, weights [FF, D]
+    PROJ(gw, gws, FF, qb, qbsq, false, gate, gsq, xn2, xn2sq)
+    PROJ(uw, uws, FF, qb, qbsq, false, up, usq, xn2, xn2sq)
+
+    Sc gs7; gs7.m0 = gsq.m0; gs7.e = gsq.e + 7;
+    for (int i = 0; i < S*FF; i++) {
+        long idx = apply_sc(gate[i], gs7) + 2048;
+        if (idx < 0) idx = 0; if (idx > 4095) idx = 4095;
+        act[i] = gate[i] * sigl[idx];
+    }
+    Sc spre = aq_span(act, 0, S*FF, gsq);
+    Sc actsq; actsq.m0 = spre.m0; actsq.e = spre.e - 16;
+    for (int i = 0; i < S*FF; i++) act[i] = act[i] * up[i];
+    Sc hmsq = aq_span(act, 0, S*FF, sc_mul(actsq, usq));
+
+    // down proj: input act [S,FF], weights dw [D, FF]
+    Sc msq;
+    {
+        for (int s = 0; s < S; s++) for (int o = 0; o < D; o++) {
+            long a = 0; for (int d = 0; d < FF; d++) a += act[s*FF + d] * long(dw[o*FF + d]);
+            acc[s*D + o] = a; }
+        Sc cmax; cmax.m0 = 0; cmax.e = 0;
+        for (int o = 0; o < D; o++) { Sc cs = sc_mul(hmsq, norm_sc(dws[2*o], int(dws[2*o+1]))); if (sc_gt(cs, cmax)) cmax = cs; }
+        for (int o = 0; o < D; o++) {
+            Sc cs = sc_mul(hmsq, norm_sc(dws[2*o], int(dws[2*o+1])));
+            Sc ratio = sc_ratio(cs, cmax);
+            for (int s = 0; s < S; s++) xn[s*D + o] = apply_sc(acc[s*D + o], ratio);
+        }
+        msq = aq_span(xn, 0, S*D, cmax);
+    }
+    for (int s = 0; s < S; s++) {
+        Sc xs; xs.m0 = xscp[2*s]; xs.e = int(xscp[2*s+1]);
+        Sc ratio = sc_ratio(msq, xs);
+        for (int d2 = 0; d2 < D; d2++) outbuf[s*D + d2] = hout[s*D + d2] + apply_sc(xn[s*D + d2], ratio);
+    }
+}
+"""
+
+// ---- host main ----
+let path = CommandLine.arguments.count > 1 ? CommandLine.arguments[1] : "layer0.bin"
+var rd = Rd(d: try! Data(contentsOf: URL(fileURLWithPath: path)))
+precondition(rd.d.prefix(8) == Data([0x4C, 0x30, 0x42, 0x49, 0x4E, 0, 0, 0]), "bad magic") // "L0BIN\0\0\0"
+rd.p = 8
+let gam = rdV1(&rd)
+let qw = rdW2(&rd); let qb = rdV1(&rd)
+let kw = rdW2(&rd); let kb = rdV1(&rd)
+let vw = rdW2(&rd); let vb = rdV1(&rd)
+let ow = rdW2(&rd)
+let xt = rdW2(&rd)
+let pan = rdV1(&rd)
+let gw = rdW2(&rd); let uw = rdW2(&rd); let dw = rdW2(&rd)
+let S = 4, HD = 64, D = 896, FF = 4864, NH = 14, NKV = 2
+let cosq = (0..<S*HD).map { _ in rd.i64() }
+let sinq = (0..<S*HD).map { _ in rd.i64() }
+let expl = (0..<256).map { _ in rd.i64() }
+let sigl = (0..<4096).map { _ in rd.i64() }
+
+guard let dev = MTLCreateSystemDefaultDevice() else { fatalError("no Metal") }
+let lib = try! dev.makeLibrary(source: SHADER, options: nil)
+let pipe = try! dev.makeComputePipelineState(function: lib.makeFunction(name: "layer_norm_profile")!)
+let q = dev.makeCommandQueue()!
+func bufI8(_ a: [Int8]) -> MTLBuffer { dev.makeBuffer(bytes: a, length: a.count, options: .storageModeShared)! }
+func bufI64(_ a: [Int64]) -> MTLBuffer { dev.makeBuffer(bytes: a, length: a.count * 8, options: .storageModeShared)! }
+func scPairs(_ w: W2) -> [Int64] { var out: [Int64] = []; for i in 0..<w.m0.count { out.append(w.m0[i]); out.append(Int64(w.e[i])) }; return out }
+
+let meta: [Int64] = [qb.m0, Int64(qb.e), kb.m0, Int64(kb.e), vb.m0, Int64(vb.e), gam.m0, Int64(gam.e), pan.m0, Int64(pan.e)]
+let scratchLen = S*D + S*NH*HD + 2*(S*NKV*HD) + 3*(S*D) + 4*(S*FF) + S*NH*HD
+let bScr = dev.makeBuffer(length: scratchLen * 8, options: .storageModeShared)!
+let bOut = dev.makeBuffer(length: S*D*8, options: .storageModeShared)!
+
+let bufs: [MTLBuffer] = [
+    bufI8(qw.w), bufI64(scPairs(qw)), bufI8(kw.w), bufI64(scPairs(kw)), bufI8(vw.w), bufI64(scPairs(vw)),
+    bufI8(ow.w), bufI64(scPairs(ow)), bufI8(gw.w), bufI64(scPairs(gw)), bufI8(uw.w), bufI64(scPairs(uw)),
+    bufI8(dw.w), bufI64(scPairs(dw)),
+    bufI64(qb.v), bufI64(kb.v), bufI64(vb.v), bufI64(gam.v), bufI64(pan.v),
+    bufI8(xt.w), bufI64(scPairs(xt)),
+    bufI64(cosq), bufI64(sinq), bufI64(expl), bufI64(sigl), bufI64(meta), bScr, bOut,
+]
+let cmd = q.makeCommandBuffer()!
+let enc = cmd.makeComputeCommandEncoder()!
+enc.setComputePipelineState(pipe)
+for (i, b) in bufs.enumerated() { enc.setBuffer(b, offset: 0, index: i) }
+enc.dispatchThreads(MTLSize(width: 1, height: 1, depth: 1), threadsPerThreadgroup: MTLSize(width: 1, height: 1, depth: 1))
+enc.endEncoding(); cmd.commit(); cmd.waitUntilCompleted()
+
+let optr = bOut.contents().bindMemory(to: Int64.self, capacity: S*D)
+var h: UInt64 = 0xcbf29ce484222325
+for i in 0..<(S*D) {
+    var v = optr[i].littleEndian
+    withUnsafeBytes(of: &v) { for b in $0 { h ^= UInt64(b); h = h &* 0x100000001b3 } }
+}
+print("backend      = Apple Metal GPU (\(dev.name)) [norm (m0,e) profile]")
+print(String(format: "layer FNV    = %016llx  (target 50a8caf4107f43f4)", h))
+print("layer[0..4]  = [\(optr[0]), \(optr[1]), \(optr[2]), \(optr[3])]  (target [265, 210, 581, -123])")
+print("MATCH        = \(String(format: "%016llx", h) == "50a8caf4107f43f4" ? "YES — Apple GPU joins the integer pool" : "NO")")
diff --git a/docs/evidence/canon_attn_sq.py b/docs/evidence/canon_attn_sq.py
new file mode 100644
index 0000000000000000000000000000000000000000..bae43eca136c1cf4e1c36141832ead1806ab6e77
--- /dev/null
+++ b/docs/evidence/canon_attn_sq.py
@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+# inc4b-2a accuracy fix: SmoothQuant on the QKV path. Migrate per-input-channel activation outlier scale
+# into gamma (RMSNorm) and the q/k/v weights, so per-tensor int8 activation quant becomes accurate while
+# the int8 GEMM stays unchanged. Compares W8A8 attention output to fp before/after SmoothQuant.
+import sys, json, struct, numpy as np
+CANON = sys.argv[1] if len(sys.argv) > 1 else "/root/models/qwen05.canon"
+D, NH, NKV, HD, THETA, S = 896, 14, 2, 64, 1000000.0, 4
+
+def read_canon(path):
+    f = open(path, "rb"); assert f.read(8) == b"CANONv1\n"
+    n = struct.unpack("<Q", f.read(8))[0]; hdr = json.loads(f.read(n)); body = f.read()
+    out = {}
+    for t in hdr["tensors"]:
+        nm, k, shp = t["name"], t["kind"], t["shape"]
+        if k == "w2d_int8_pcs":
+            o, i = shp
+            w = np.frombuffer(body[t["w_off"]:t["w_off"]+o*i], dtype=np.int8).reshape(o, i)
+            sc = np.frombuffer(body[t["s_off"]:t["s_off"]+o*8], dtype=np.int32).reshape(o, 2)
+            out[nm] = ("w", w, sc[:, 0].astype(np.float64) * 2.0**(sc[:, 1].astype(np.float64)-31))
+        else:
+            v = np.frombuffer(body[t["w_off"]:t["w_off"]+shp[0]*4], dtype=np.int32)
+            m0, sh = struct.unpack("<ii", body[t["s_off"]:t["s_off"]+8])
+            out[nm] = ("v", v, m0 * 2.0**(sh-31))
+    return out
+T = read_canon(CANON)
+wd = lambda n: T[n][1].astype(np.float64) * T[n][2][:, None]
+vd = lambda n: T[n][1].astype(np.float64) * T[n][2]
+L = "model.layers.0."
+Wq, Wk, Wv, Wo = wd(L+"self_attn.q_proj.weight"), wd(L+"self_attn.k_proj.weight"), wd(L+"self_attn.v_proj.weight"), wd(L+"self_attn.o_proj.weight")
+bq, bk, bv = vd(L+"self_attn.q_proj.bias"), vd(L+"self_attn.k_proj.bias"), vd(L+"self_attn.v_proj.bias")
+gin = vd(L+"input_layernorm.weight")
+Wemb, semb = T["model.embed_tokens.weight"][1], T["model.embed_tokens.weight"][2]
+emb = lambda ids: np.stack([Wemb[i].astype(np.float64)*semb[i] for i in ids])
+X = emb([9707, 11, 1879, 30][:S])
+
+inv_freq = 1.0/(THETA**(np.arange(0, HD, 2)/HD)); ang = np.outer(np.arange(S), inv_freq)
+cos_f = np.concatenate([np.cos(ang)]*2, 1); sin_f = np.concatenate([np.sin(ang)]*2, 1)
+cosQ = np.clip(np.rint(cos_f*32768), -32768, 32767).astype(np.int64); sinQ = np.clip(np.rint(sin_f*32768), -32768, 32767).astype(np.int64)
+rhf = lambda x: np.concatenate([-x[..., HD//2:], x[..., :HD//2]], -1)
+rope_fp = lambda x: x*cos_f[:, None, :] + rhf(x)*sin_f[:, None, :]
+def rope_int(xq, clip=127):
+    rh = np.concatenate([-xq[..., HD//2:].astype(np.int64), xq[..., :HD//2].astype(np.int64)], -1)
+    return np.clip((xq.astype(np.int64)*cosQ[:, None, :] + rh*sinQ[:, None, :] + 16384) >> 15, -clip, clip)
+def qdyn(Tf): a = float(np.max(np.abs(Tf))) or 1.0; return np.clip(np.rint(Tf/(a/127)), -127, 127).astype(np.int8), a/127
+def qpc(Wf): amax = np.max(np.abs(Wf), 1); inv = np.where(amax > 0, 127/amax, 0); return np.clip(np.rint(Wf*inv[:, None]), -127, 127).astype(np.int8), np.where(amax > 0, amax/127, 1.0)
+imm = lambda aq, wq: aq.astype(np.int64) @ wq.astype(np.int64).T
+rms_fp = lambda h, g: h/np.sqrt(np.mean(h*h, 1, keepdims=True)+1e-6)*g
+def build_exp(n=28):
+    ONE = 1 << 16; t = np.zeros(256, np.int64)
+    for d in range(256):
+        x = -d*(ONE//64); e = ONE; k = n
+        while k >= 1: e = ONE+((x*e)//ONE)//k; k -= 1
+        t[d] = max(0, e)
+    return t
+EXP = build_exp()
+
+def block_int(gam, wq_i, wqs, wk_i, wks, wv_i, wvs, alvl=127, fpsm=False):
+    def aq(Tf):  # dynamic per-tensor activation quant to +-alvl levels
+        a = float(np.max(np.abs(Tf))) or 1.0; return np.clip(np.rint(Tf/(a/alvl)), -alvl, alvl).astype(np.int64), a/alvl
+    Xq, Xs = aq(X)
+    ss = np.sum(Xq**2, 1); mean = ss//D+1
+    inv = np.array([int(np.floor(np.sqrt((1 << 40)/m))) for m in mean], np.int64)  # ~2^20/sqrt(mean) (Q20)
+    y = Xq*inv[:, None]                                     # normalize(Xq) in Q20 (full precision kept)
+    yg = y*np.rint(gam*(1 << 12)).astype(np.int64)          # = rmsnorm_out * 2^32  (integer)
+    xn_q, xn_s_raw = aq(yg.astype(np.float64))             # xn_q*xn_s_raw ≈ yg
+    xn_s = xn_s_raw / (1 << 32)                             # so xn_q*xn_s ≈ rmsnorm_out
+    def proj(wi, ws): return imm(xn_q, wi).astype(np.float64) * (xn_s*ws)[None, :]
+    qf = proj(wq_i, wqs).reshape(S, NH, HD) + bq.reshape(NH, HD)[None]
+    kf = proj(wk_i, wks).reshape(S, NKV, HD) + bk.reshape(NKV, HD)[None]
+    vf = proj(wv_i, wvs).reshape(S, NKV, HD) + bv.reshape(NKV, HD)[None]
+    qq, qs = aq(qf); kq, ks = aq(kf); vf2 = vf
+    qq, kq = rope_int(qq, alvl), rope_int(kq, alvl)
+    kq14 = np.repeat(kq, NH//NKV, 1)
+    scores = np.einsum('shd,thd->hst', qq.astype(np.int64), kq14.astype(np.int64))
+    C = qs*ks/np.sqrt(HD)
+    probs = np.zeros((NH, S, S))
+    for h in range(NH):
+        for s in range(S):
+            row = scores[h, s, :s+1]; m = row.max()
+            if fpsm:
+                e = np.exp((row - m).astype(np.float64) * C); probs[h, s, :s+1] = e / e.sum()
+            else:
+                d = np.clip(((m-row).astype(np.float64)*C*64).round().astype(int), 0, 255)
+                e = EXP[d]; probs[h, s, :s+1] = (e.astype(np.int64) << 16)//int(e.sum())/(1 << 16)
+    vf14 = np.repeat(vf2.reshape(S, NKV, HD), NH//NKV, 1)
+    attn = np.einsum('hst,thd->shd', probs, vf14).reshape(S, D)
+    aq, as_ = qdyn(attn); _, wo, wosc = T[L+"self_attn.o_proj.weight"]
+    o = imm(aq, wo).astype(np.float64)*(as_*wosc)[None, :]
+    return o
+
+# NOTE: proj() folds only weight scale; the RMSNorm output scale is absorbed by re-quant. The bias is added
+# post-hoc in fp here (scale bookkeeping is fp in this correctness cut).
+
+# fp reference (original weights)
+xn = rms_fp(X, gin)
+q = (xn@Wq.T+bq).reshape(S, NH, HD); k = (xn@Wk.T+bk).reshape(S, NKV, HD); v = (xn@Wv.T+bv).reshape(S, NKV, HD)
+q, k = rope_fp(q), rope_fp(k); k14 = np.repeat(k, NH//NKV, 1); v14 = np.repeat(v, NH//NKV, 1)
+sc = np.einsum('shd,thd->hst', q, k14)/np.sqrt(HD)
+for h in range(NH):
+    for s in range(S): sc[h, s, s+1:] = -1e30
+af = np.zeros((S, NH, HD))
+for h in range(NH):
+    p = np.exp(sc[h]-sc[h].max(1, keepdims=True)); p /= p.sum(1, keepdims=True); af[:, h, :] = p@v14[:, h, :]
+o_fp = af.reshape(S, D)@Wo.T
+rel = lambda a, b: float(np.sqrt(np.sum((a-b)**2)/(np.sum(b*b)+1e-12)))
+
+# baseline: per-tensor, no smoothing
+wq_i, wqs = qpc(Wq); wk_i, wks = qpc(Wk); wv_i, wvs = qpc(Wv)
+o_base = block_int(gin, wq_i, wqs, wk_i, wks, wv_i, wvs)
+
+# SmoothQuant: calibration per-channel activation max, fold s into gamma + qkv weights
+calib = rms_fp(emb(list(range(1, 129))), gin)
+act_max = np.max(np.abs(calib), 0)                      # [D]
+w_max = np.max(np.abs(np.concatenate([Wq, Wk, Wv], 0)), 0)  # [D]
+alpha = 0.5
+s = np.clip(np.power(act_max, alpha)/np.power(np.maximum(w_max, 1e-9), 1-alpha), 1e-2, 1e2)
+gin_s = gin/s
+Wq_s, Wk_s, Wv_s = Wq*s[None, :], Wk*s[None, :], Wv*s[None, :]
+wq_i2, wqs2 = qpc(Wq_s); wk_i2, wks2 = qpc(Wk_s); wv_i2, wvs2 = qpc(Wv_s)
+o_sq = block_int(gin_s, wq_i2, wqs2, wk_i2, wks2, wv_i2, wvs2)
+
+o_a16 = block_int(gin, wq_i, wqs, wk_i, wks, wv_i, wvs, alvl=32767)          # W8A16, no smoothing
+o_sq_a16 = block_int(gin_s, wq_i2, wqs2, wk_i2, wks2, wv_i2, wvs2, alvl=32767)  # W8A16 + SmoothQuant
+print(f"attention out rel err (int vs fp):")
+print(f"  W8A8  per-tensor            = {rel(o_base, o_fp):.4f}")
+print(f"  W8A8  SmoothQuant a=0.5     = {rel(o_sq, o_fp):.4f}")
+print(f"  W8A16 per-tensor            = {rel(o_a16, o_fp):.4f}")
+print(f"  W8A16 + SmoothQuant        = {rel(o_sq_a16, o_fp):.4f}")
+o_a16_fpsm = block_int(gin, wq_i, wqs, wk_i, wks, wv_i, wvs, alvl=32767, fpsm=True)
+o_a8_fpsm = block_int(gin, wq_i, wqs, wk_i, wks, wv_i, wvs, alvl=127, fpsm=True)
+print(f"  W8A16 + fp-softmax         = {rel(o_a16_fpsm, o_fp):.4f}   <- isolates integer softmax")
+print(f"  W8A8  + fp-softmax         = {rel(o_a8_fpsm, o_fp):.4f}")
+print(f"  act outlier ratio max/median = {act_max.max()/np.median(act_max):.1f}x")
diff --git a/docs/evidence/canon_cuda.cu b/docs/evidence/canon_cuda.cu
new file mode 100644
index 0000000000000000000000000000000000000000..0eded7f69b595ff85ff61588b7b8eb7e0c0104fe
--- /dev/null
+++ b/docs/evidence/canon_cuda.cu
@@ -0,0 +1,75 @@
+// Canonical int8 GEMM on NVIDIA CUDA GPU (Ada sm_89) — must reproduce the CPU/Metal fingerprint.
+// Same splitmix64 inputs + same int32 GEMM as canon_int.rs / canon_metal.swift.
+// Target INT fnv: 4b138ed70d137781
+//
+// Build/run:  nvcc -O3 -arch=sm_89 canon_cuda.cu -o canon_cuda && ./canon_cuda
+
+#include <cstdio>
+#include <cstdint>
+#include <vector>
+#include <cuda_runtime.h>
+
+static inline uint64_t splitmix64(uint64_t &s) {
+    s += 0x9E3779B97F4A7C15ULL;
+    uint64_t z = s;
+    z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9ULL;
+    z = (z ^ (z >> 27)) * 0x94D049BB133111EBULL;
+    return z ^ (z >> 31);
+}
+static std::vector<int8_t> genI8(size_t n, uint64_t seed) {
+    uint64_t s = seed; std::vector<int8_t> v; v.reserve(n);
+    for (size_t i = 0; i < n; i++) v.push_back((int8_t)(splitmix64(s) % 128));
+    return v;
+}
+static uint64_t fnv(const uint8_t *p, size_t n) {
+    uint64_t h = 0xcbf29ce484222325ULL;
+    for (size_t i = 0; i < n; i++) { h ^= (uint64_t)p[i]; h *= 0x100000001b3ULL; }
+    return h;
+}
+
+__global__ void gemm_i8(const int8_t *A, const int8_t *B, int32_t *C,
+                        unsigned M, unsigned K, unsigned N) {
+    unsigned gid = blockIdx.x * blockDim.x + threadIdx.x;
+    if (gid >= M * N) return;
+    unsigned i = gid / N, j = gid % N;
+    int acc = 0;                                   // int32 accumulation
+    for (unsigned t = 0; t < K; t++) {
+        acc += (int)A[i * K + t] * (int)B[t * N + j];
+    }
+    C[gid] = acc;
+}
+
+int main() {
+    const unsigned M = 32, K = 8192, N = 32;
+    std::vector<int8_t> a = genI8((size_t)M * K, 0xA11CE);
+    std::vector<int8_t> b = genI8((size_t)K * N, 0xB0B);
+    std::vector<int32_t> c((size_t)M * N, 0);
+
+    int8_t *dA, *dB; int32_t *dC;
+    cudaMalloc(&dA, a.size()); cudaMalloc(&dB, b.size());
+    cudaMalloc(&dC, c.size() * sizeof(int32_t));
+    cudaMemcpy(dA, a.data(), a.size(), cudaMemcpyHostToDevice);
+    cudaMemcpy(dB, b.data(), b.size(), cudaMemcpyHostToDevice);
+    unsigned total = M * N, tpb = 64, blocks = (total + tpb - 1) / tpb;
+    gemm_i8<<<blocks, tpb>>>(dA, dB, dC, M, K, N);
+    cudaError_t err = cudaDeviceSynchronize();
+    if (err != cudaSuccess) { printf("cuda error: %s\n", cudaGetErrorString(err)); return 1; }
+    cudaMemcpy(c.data(), dC, c.size() * sizeof(int32_t), cudaMemcpyDeviceToHost);
+
+    // serialize int32 little-endian, FNV
+    std::vector<uint8_t> bytes; bytes.reserve(c.size() * 4);
+    for (int32_t v32 : c) {
+        uint32_t v = (uint32_t)v32;
+        bytes.push_back(v & 0xff); bytes.push_back((v >> 8) & 0xff);
+        bytes.push_back((v >> 16) & 0xff); bytes.push_back((v >> 24) & 0xff);
+    }
+    uint64_t h = fnv(bytes.data(), bytes.size());
+    cudaDeviceProp prop; cudaGetDeviceProperties(&prop, 0);
+    printf("backend             = NVIDIA CUDA GPU (%s, sm_%d%d)\n", prop.name, prop.major, prop.minor);
+    printf("shape M,K,N         = %u,%u,%u\n", M, K, N);
+    printf("INT  gpu  fnv       = %016llx\n", (unsigned long long)h);
+    printf("TARGET (CPU/Metal)  = 4b138ed70d137781\n");
+    printf("MATCH               = %s\n", h == 0x4b138ed70d137781ULL ? "OK byte-identical" : "MISMATCH");
+    cudaFree(dA); cudaFree(dB); cudaFree(dC);
+    return 0;
+}
diff --git a/docs/evidence/canon_dump.py b/docs/evidence/canon_dump.py
new file mode 100644
index 0000000000000000000000000000000000000000..36c897f612b2821d2017769fc9f4cfcebb0bac00
--- /dev/null
+++ b/docs/evidence/canon_dump.py
@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+import sys, json, struct
+p = sys.argv[1]
+with open(p, "rb") as f:
+    assert f.read(8) == b"CANONv1\n"
+    n = struct.unpack("<Q", f.read(8))[0]
+    hdr = json.loads(f.read(n))
+print("format", hdr["format"], "model", hdr["model"], "rounding", hdr["rounding"])
+for t in hdr["tensors"]:
+    nm = t["name"]
+    if nm.startswith("model.layers.0.") or "layers." not in nm:
+        print(f"{t['kind']:16s} {str(t['shape']):16s} {nm}")
diff --git a/docs/evidence/canon_extract.py b/docs/evidence/canon_extract.py
new file mode 100644
index 0000000000000000000000000000000000000000..da5d7cb23131c36e6b28641912eb3f4a259b9109
--- /dev/null
+++ b/docs/evidence/canon_extract.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+# Extract the layer-0 attention tensors (+ embedding rows for the test tokens) from qwen05.canon into a
+# flat little-endian binary that standalone rustc can read with no JSON parser. Raw (m0,shift) scales are
+# passed through verbatim; the Rust port replicates qm_from_fixed.
+import sys, json, struct
+CANON, OUT = sys.argv[1], sys.argv[2]
+IDS = [9707, 11, 1879, 30]
+f = open(CANON, "rb"); assert f.read(8) == b"CANONv1\n"
+n = struct.unpack("<Q", f.read(8))[0]; hdr = json.loads(f.read(n)); body = f.read()
+dir = {t["name"]: t for t in hdr["tensors"]}
+
+def w2d(name):     # -> (out, in, int8 bytes, [(m0,shift)]*out)
+    t = dir[name]; o, i = t["shape"]
+    w = body[t["w_off"]:t["w_off"]+o*i]
+    sc = [struct.unpack("<ii", body[t["s_off"]+8*c:t["s_off"]+8*c+8]) for c in range(o)]
+    return o, i, w, sc
+def v1d(name):     # -> (n, int32 bytes, (m0,shift))
+    t = dir[name]; nn = t["shape"][0]
+    v = body[t["w_off"]:t["w_off"]+nn*4]
+    m0, sh = struct.unpack("<ii", body[t["s_off"]:t["s_off"]+8])
+    return nn, v, (m0, sh)
+
+out = bytearray(b"L0BIN\0\0\0")
+def put_u32(x): out.extend(struct.pack("<I", x))
+def put_scales(scs):
+    put_u32(len(scs))
+    for m0, sh in scs: out.extend(struct.pack("<ii", m0, sh))
+def put_w2d(name):
+    o, i, w, sc = w2d(name); out.append(0); put_u32(o); put_u32(i); out.extend(w); put_scales(sc)
+def put_v1d(name):
+    nn, v, s = v1d(name); out.append(1); put_u32(nn); put_u32(0); out.extend(v); put_scales([s])
+
+L = "model.layers.0."
+put_v1d(L+"input_layernorm.weight")
+put_w2d(L+"self_attn.q_proj.weight"); put_v1d(L+"self_attn.q_proj.bias")
+put_w2d(L+"self_attn.k_proj.weight"); put_v1d(L+"self_attn.k_proj.bias")
+put_w2d(L+"self_attn.v_proj.weight"); put_v1d(L+"self_attn.v_proj.bias")
+put_w2d(L+"self_attn.o_proj.weight")
+# X: 4 embedding rows (as a w2d [4, 896] int8 + 4 scales)
+et = dir["model.embed_tokens.weight"]; D = et["shape"][1]
+out.append(0); put_u32(len(IDS)); put_u32(D)
+scs = []
+for tid in IDS:
+    out.extend(body[et["w_off"]+tid*D: et["w_off"]+(tid+1)*D])
+    scs.append(struct.unpack("<ii", body[et["s_off"]+8*tid: et["s_off"]+8*tid+8]))
+put_scales(scs)
+# MLP tensors (4b-3): post_attention_layernorm + gate/up/down (no bias)
+put_v1d(L+"post_attention_layernorm.weight")
+put_w2d(L+"mlp.gate_proj.weight")
+put_w2d(L+"mlp.up_proj.weight")
+put_w2d(L+"mlp.down_proj.weight")
+
+# RoPE Q15 tables + integer EXP LUT (appended as i64 LE, fixed sizes: S*HD, S*HD, 256)
+import numpy as np
+HD = 64; THETA = 1000000.0; S = len(IDS)
+inv_freq = 1.0/(THETA**(np.arange(0, HD, 2)/HD)); ang = np.outer(np.arange(S), inv_freq)
+cosF = np.concatenate([np.cos(ang)]*2, 1); sinF = np.concatenate([np.sin(ang)]*2, 1)
+cosQ = np.clip(np.rint(cosF*32768), -32768, 32767).astype(np.int64).flatten()
+sinQ = np.clip(np.rint(sinF*32768), -32768, 32767).astype(np.int64).flatten()
+def build_exp(nt=28):
+    ONE = 1 << 16; t = []
+    for d in range(256):
+        x = -d*(ONE//64); e = ONE; k = nt
+        while k >= 1: e = ONE+((x*e)//ONE)//k; k -= 1
+        t.append(max(0, e))
+    return t
+EXP = build_exp()
+SIG = np.clip(np.rint(1.0/(1.0+np.exp(-(np.arange(4096)-2048)/128.0))*(1 << 16)), 0, 1 << 16).astype(np.int64)
+for arr in [cosQ, sinQ, np.array(EXP, np.int64), SIG]:
+    for x in arr: out.extend(struct.pack("<q", int(x)))
+
+open(OUT, "wb").write(out)
+print(f"wrote {OUT}: {len(out)} bytes, tokens={IDS}, +rope/exp/sig tables +mlp")
diff --git a/docs/evidence/canon_extract_full.py b/docs/evidence/canon_extract_full.py
new file mode 100644
index 0000000000000000000000000000000000000000..a152ebcad0a4d7354dcbdabd15a6c52ff27df0bd
--- /dev/null
+++ b/docs/evidence/canon_extract_full.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# Full-model extractor: qwen05.canon -> model.bin (flat LE, no JSON) for the Rust/CUDA full-model ports.
+# Layout: "QCM0\0\0\0\0" | u32 NL | u32 SMAX | embed(w2d) | NL x [ln1(v1d) qw qb kw kb vw vb ow(w2d/v1d)
+# ln2(v1d) gate up down(w2d)] | final_norm(v1d) | cos[SMAX*HD] sin[SMAX*HD] EXP[2048] SIG[16384] (i64 LE)
+import sys, json, struct
+import numpy as np
+CANON, OUT = sys.argv[1], sys.argv[2]
+NL, SMAX, HD, THETA = 24, 32, 64, 1000000.0
+f = open(CANON, "rb"); assert f.read(8) == b"CANONv1\n"
+n = struct.unpack("<Q", f.read(8))[0]; hdr = json.loads(f.read(n)); body = f.read()
+dir = {t["name"]: t for t in hdr["tensors"]}
+out = bytearray(b"QCM0\0\0\0\0")
+out.extend(struct.pack("<II", NL, SMAX))
+def put_scales(scs):
+    out.extend(struct.pack("<I", len(scs)))
+    for m0, sh in scs: out.extend(struct.pack("<ii", m0, sh))
+def put_w2d(name):
+    t = dir[name]; o, i = t["shape"]
+    out.append(0); out.extend(struct.pack("<II", o, i))
+    out.extend(body[t["w_off"]:t["w_off"]+o*i])
+    put_scales([struct.unpack("<ii", body[t["s_off"]+8*c:t["s_off"]+8*c+8]) for c in range(o)])
+def put_v1d(name):
+    t = dir[name]; nn = t["shape"][0]
+    out.append(1); out.extend(struct.pack("<II", nn, 0))
+    out.extend(body[t["w_off"]:t["w_off"]+nn*4])
+    put_scales([struct.unpack("<ii", body[t["s_off"]:t["s_off"]+8])])
+put_w2d("model.embed_tokens.weight")
+for l in range(NL):
+    L = f"model.layers.{l}."
+    put_v1d(L+"input_layernorm.weight")
+    put_w2d(L+"self_attn.q_proj.weight"); put_v1d(L+"self_attn.q_proj.bias")
+    put_w2d(L+"self_attn.k_proj.weight"); put_v1d(L+"self_attn.k_proj.bias")
+    put_w2d(L+"self_attn.v_proj.weight"); put_v1d(L+"self_attn.v_proj.bias")
+    put_w2d(L+"self_attn.o_proj.weight")
+    put_v1d(L+"post_attention_layernorm.weight")
+    put_w2d(L+"mlp.gate_proj.weight"); put_w2d(L+"mlp.up_proj.weight"); put_w2d(L+"mlp.down_proj.weight")
+put_v1d("model.norm.weight")
+inv_freq = 1.0/(THETA**(np.arange(0, HD, 2)/HD)); ang = np.outer(np.arange(SMAX), inv_freq)
+cosF = np.concatenate([np.cos(ang)]*2, 1); sinF = np.concatenate([np.sin(ang)]*2, 1)
+cosQ = np.clip(np.rint(cosF*32768), -32768, 32767).astype(np.int64).flatten()
+sinQ = np.clip(np.rint(sinF*32768), -32768, 32767).astype(np.int64).flatten()
+def build_exp(nt=28):
+    ONE = 1 << 16; t = []
+    for d in range(2048):
+        x = -d*(ONE//512); e = ONE; k = nt
+        while k >= 1: e = ONE+((x*e)//ONE)//k; k -= 1
+        t.append(max(0, e))
+    return t
+EXP = build_exp()
+SIG = np.clip(np.rint(1.0/(1.0+np.exp(-(np.arange(16384)-8192)/512.0))*(1 << 16)), 0, 1 << 16).astype(np.int64)
+for arr in [cosQ, sinQ, np.array(EXP, np.int64), SIG]:
+    for x in arr: out.extend(struct.pack("<q", int(x)))
+open(OUT, "wb").write(out)
+import hashlib
+print(f"wrote {OUT}: {len(out):,} bytes  blake2b16={hashlib.blake2b(bytes(out), digest_size=16).hexdigest()}")
diff --git a/docs/evidence/canon_int.rs b/docs/evidence/canon_int.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c5b3cab4f8dc81170f52d7a9d328dfebd9ebb868
--- /dev/null
+++ b/docs/evidence/canon_int.rs
@@ -0,0 +1,126 @@
+// Canonical integer compute — cross-hardware bit-identity demonstration.
+//
+// CORE THEOREM. int32 addition is a commutative ring even under two's-complement wrapping:
+//   (a + b) + c == a + (b + c)   and   a + b == b + a   (mod 2^32), exactly, always.
+// Therefore an int8×int8→int32 GEMM yields byte-identical results REGARDLESS of the reduction
+// order — sequential, pairwise tree, SIMD-lane, GPU warp-shuffle, multi-tile — i.e. regardless of
+// microarchitecture (RTX 20 sm_75 vs RTX 40 sm_89, Apple, CPU, …).
+// IEEE-754 float addition is NOT associative, so a float GEMM's result depends on the order and
+// hence on the hardware. This program demonstrates both facts on real hardware.
+//
+// Build/run (no deps):  rustc -O canon_int.rs -o canon_int && ./canon_int
+
+// ---- deterministic PRNG (splitmix64) so both machines generate identical inputs ----
+fn splitmix64(s: &mut u64) -> u64 {
+    *s = s.wrapping_add(0x9E3779B97F4A7C15);
+    let mut z = *s;
+    z = (z ^ (z >> 30)).wrapping_mul(0xBF58476D1CE4E5B9);
+    z = (z ^ (z >> 27)).wrapping_mul(0x94D049BB133111EB);
+    z ^ (z >> 31)
+}
+// Values in [0,127] (valid int8 magnitudes) so the int32 accumulator grows past 2^24 — the regime
+// where fp32 can no longer hold the running sum exactly and its result becomes order-dependent.
+fn gen_i8(n: usize, seed: u64) -> Vec<i8> {
+    let mut s = seed;
+    (0..n).map(|_| (splitmix64(&mut s) % 128) as i8).collect()
+}
+
+// ---- int8×int8 -> int32 GEMM, two DIFFERENT reduction orders over k ----
+fn dot_i32_seq(a: &[i8], b: &[i8]) -> i32 {
+    let mut acc: i32 = 0;
+    for i in 0..a.len() {
+        acc = acc.wrapping_add(a[i] as i32 * b[i] as i32);
+    }
+    acc
+}
+// pairwise / tree reduction — a genuinely different associativity grouping
+fn dot_i32_tree(a: &[i8], b: &[i8]) -> i32 {
+    let mut prod: Vec<i32> = (0..a.len()).map(|i| a[i] as i32 * b[i] as i32).collect();
+    while prod.len() > 1 {
+        let mut next = Vec::with_capacity(prod.len().div_ceil(2));
+        let mut i = 0;
+        while i + 1 < prod.len() {
+            next.push(prod[i].wrapping_add(prod[i + 1]));
+            i += 2;
+        }
+        if i < prod.len() { next.push(prod[i]); }
+        prod = next;
+    }
+    prod[0]
+}
+// ---- same two orders in f32 (cast int8 to f32) ----
+fn dot_f32_seq(a: &[i8], b: &[i8]) -> f32 {
+    let mut acc = 0f32;
+    for i in 0..a.len() { acc += a[i] as f32 * b[i] as f32; }
+    acc
+}
+fn dot_f32_tree(a: &[i8], b: &[i8]) -> f32 {
+    let mut prod: Vec<f32> = (0..a.len()).map(|i| a[i] as f32 * b[i] as f32).collect();
+    while prod.len() > 1 {
+        let mut next = Vec::with_capacity(prod.len().div_ceil(2));
+        let mut i = 0;
+        while i + 1 < prod.len() { next.push(prod[i] + prod[i + 1]); i += 2; }
+        if i < prod.len() { next.push(prod[i]); }
+        prod = next;
+    }
+    prod[0]
+}
+
+// ---- fixed-point requantization int32 -> int8 (integer-only, gemmlowp/TFLite style) ----
+// q = clamp( (acc * mult + round) >> shift , -127, 127 ), round = 1<<(shift-1). Deterministic, no fp.
+fn requant_i8(acc: i32, mult: i32, shift: u32) -> i8 {
+    let round: i64 = 1i64 << (shift - 1);
+    let v = ((acc as i64 * mult as i64) + round) >> shift;
+    v.clamp(-127, 127) as i8
+}
+
+// ---- FNV-1a 64 over bytes: identical bytes -> identical fingerprint ----
+fn fnv(bytes: &[u8]) -> u64 {
+    let mut h: u64 = 0xcbf29ce484222325;
+    for &b in bytes { h ^= b as u64; h = h.wrapping_mul(0x100000001b3); }
+    h
+}
+
+fn main() {
+    let (m, k, n) = (32usize, 8192usize, 32usize); // K large so f32 loses precision across orders
+    let a = gen_i8(m * k, 0xA11CE); // weights
+    let b = gen_i8(k * n, 0xB0B); // activations
+    let arow = |i: usize| &a[i * k..(i + 1) * k];
+    // B is K×N; take column j as a strided gather into a contiguous vec
+    let bcol = |j: usize| -> Vec<i8> { (0..k).map(|t| b[t * n + j]).collect() };
+
+    let mut int_seq = vec![0i32; m * n];
+    let mut int_tree = vec![0i32; m * n];
+    let mut fp_seq = vec![0f32; m * n];
+    let mut fp_tree = vec![0f32; m * n];
+    for i in 0..m {
+        for j in 0..n {
+            let bc = bcol(j);
+            int_seq[i * n + j] = dot_i32_seq(arow(i), &bc);
+            int_tree[i * n + j] = dot_i32_tree(arow(i), &bc);
+            fp_seq[i * n + j] = dot_f32_seq(arow(i), &bc);
+            fp_tree[i * n + j] = dot_f32_tree(arow(i), &bc);
+        }
+    }
+    let bytes_i32 = |v: &[i32]| -> Vec<u8> { v.iter().flat_map(|x| x.to_le_bytes()).collect() };
+    let bytes_f32 = |v: &[f32]| -> Vec<u8> { v.iter().flat_map(|x| x.to_bits().to_le_bytes()).collect() };
+
+    let int_seq_h = fnv(&bytes_i32(&int_seq));
+    let int_tree_h = fnv(&bytes_i32(&int_tree));
+    let fp_seq_h = fnv(&bytes_f32(&fp_seq));
+    let fp_tree_h = fnv(&bytes_f32(&fp_tree));
+
+    // canonical commitment = requantized int output (what a next layer would consume)
+    let q: Vec<i8> = int_seq.iter().map(|&x| requant_i8(x, 1_073_741_824, 38)).collect();
+    let canon = fnv(&q.iter().map(|&x| x as u8).collect::<Vec<u8>>());
+
+    println!("arch                = {}", std::env::consts::ARCH);
+    println!("shape M,K,N         = {},{},{}", m, k, n);
+    println!("INT  seq  fnv       = {:016x}", int_seq_h);
+    println!("INT  tree fnv       = {:016x}", int_tree_h);
+    println!("INT  order-invariant= {}", if int_seq_h == int_tree_h { "MATCH  ✅ (hardware-independent)" } else { "DIFFER ❌" });
+    println!("FP32 seq  fnv       = {:016x}", fp_seq_h);
+    println!("FP32 tree fnv       = {:016x}", fp_tree_h);
+    println!("FP32 order-invariant= {}", if fp_seq_h == fp_tree_h { "MATCH (coincidence at this K)" } else { "DIFFER ⚠️  (order-dependent → hardware-dependent)" });
+    println!("CANONICAL commitment= {:016x}   <-- must be identical on every machine/backend", canon);
+}
diff --git a/docs/evidence/canon_layer.rs b/docs/evidence/canon_layer.rs
new file mode 100644
index 0000000000000000000000000000000000000000..346db305b4e3ad00784a715ea2fbaa3ca41ece7b
--- /dev/null
+++ b/docs/evidence/canon_layer.rs
@@ -0,0 +1,83 @@
+// Canonical integer LAYER (increment 3): int8 GEMM -> +int32 bias -> fixed-point requant -> integer LUT.
+// NO floating point anywhere on the compute path. Must be byte-identical across CPU / Metal / CUDA.
+// This CPU build is the reference; it prints the target fingerprint the GPU builds must reproduce.
+//
+// Build/run:  rustc -O canon_layer.rs -o canon_layer && ./canon_layer
+
+fn splitmix64(s: &mut u64) -> u64 {
+    *s = s.wrapping_add(0x9E3779B97F4A7C15);
+    let mut z = *s;
+    z = (z ^ (z >> 30)).wrapping_mul(0xBF58476D1CE4E5B9);
+    z = (z ^ (z >> 27)).wrapping_mul(0x94D049BB133111EB);
+    z ^ (z >> 31)
+}
+fn gen_i8(n: usize, seed: u64) -> Vec<i8> {
+    let mut s = seed;
+    (0..n).map(|_| (splitmix64(&mut s) % 128) as i8).collect()
+}
+fn fnv(bytes: &[u8]) -> u64 {
+    let mut h: u64 = 0xcbf29ce484222325;
+    for &b in bytes { h ^= b as u64; h = h.wrapping_mul(0x100000001b3); }
+    h
+}
+
+// --- pinned integer nonlinearity (fast-sigmoid SiLU), fully integer -> a 256-entry int8 LUT ---
+// silu(x) = x*sigmoid(x); sigmoid via fast-sigmoid x/(1+|x|). Fixed-point scale S, truncating int div
+// (toward zero — identical semantics in Rust / CUDA / Metal). No fp.
+fn silu_int(x: i32) -> i8 {
+    const S: i32 = 4096;
+    let ax = x.abs();
+    let fs = (x * S) / (1 + ax);   // ~[-S, S]
+    let sig = (fs + S) / 2;        // ~[0, S]
+    let silu = (x * sig) / S;      // ~ x*sigmoid(x)
+    silu.clamp(-127, 127) as i8
+}
+fn build_lut() -> [i8; 256] {
+    let mut t = [0i8; 256];
+    for i in 0..256 { t[i] = silu_int(i as i32 - 128); } // index = q + 128, q in [-128,127]
+    t
+}
+
+// --- fixed-point requantization int32 -> int8 (gemmlowp/TFLite): integer-only, defined rounding ---
+fn requant(pre: i32, m0: i32, shift: u32) -> i8 {
+    let round: i64 = 1i64 << (shift - 1);
+    let v = ((pre as i64) * (m0 as i64) + round) >> shift;
+    v.clamp(-127, 127) as i8
+}
+
+fn main() {
+    let (m, k, n) = (16usize, 2048usize, 16usize);
+    let x = gen_i8(m * k, 0x51); // activations, row-major M×K
+    let w = gen_i8(k * n, 0x52); // weights, row-major K×N
+    // per-output-channel bias (i32) and requant multiplier (i32); shift fixed. Deterministic.
+    let mut sb = 0x53u64;
+    let bias: Vec<i32> = (0..n).map(|_| -(8_300_000i32) + (splitmix64(&mut sb) % 400_000) as i32).collect();
+    let mut sm = 0x54u64;
+    let m0: Vec<i32> = (0..n).map(|_| 700 + (splitmix64(&mut sm) % 200) as i32).collect();
+    let shift: u32 = 20;
+    let lut = build_lut();
+
+    let mut out = vec![0i8; m * n];
+    let mut qmin = i32::MAX; let mut qmax = i32::MIN; let mut qsum = 0i64;
+    for i in 0..m {
+        for j in 0..n {
+            let mut acc: i32 = 0;
+            for t in 0..k { acc = acc.wrapping_add(x[i * k + t] as i32 * w[t * n + j] as i32); }
+            let pre = acc.wrapping_add(bias[j]);
+            let q = requant(pre, m0[j], shift);
+            qmin = qmin.min(q as i32); qmax = qmax.max(q as i32); qsum += q as i64;
+            out[i * n + j] = lut[(q as i32 + 128) as usize];
+        }
+    }
+    let bytes: Vec<u8> = out.iter().map(|&x| x as u8).collect();
+    let h = fnv(&bytes);
+    // LUT fingerprint too (so GPU builds can confirm identical pinned table)
+    let lut_h = fnv(&lut.iter().map(|&x| x as u8).collect::<Vec<u8>>());
+
+    println!("backend             = CPU ({})", std::env::consts::ARCH);
+    println!("shape M,K,N         = {},{},{}", m, k, n);
+    println!("q range (post-requant) = [{}, {}] mean~{}", qmin, qmax, qsum / (m * n) as i64);
+    println!("out[0..8]           = {:?}", &out[0..8]);
+    println!("LUT   fnv           = {:016x}", lut_h);
+    println!("LAYER fnv           = {:016x}   <-- GPU builds must reproduce this", h);
+}
diff --git a/docs/evidence/canon_layer_cuda.cu b/docs/evidence/canon_layer_cuda.cu
new file mode 100644
index 0000000000000000000000000000000000000000..5aa12eb2a2485a9abd935c064380a4335bd8dfcb
--- /dev/null
+++ b/docs/evidence/canon_layer_cuda.cu
@@ -0,0 +1,89 @@
+// Canonical integer LAYER on NVIDIA CUDA GPU (increment 3). Must reproduce the CPU/Metal fingerprints:
+//   LAYER fnv = 440bd1b93d991fe0 , LUT fnv = 8ab2052fcf2b005a
+// Build/run:  nvcc -O3 -arch=sm_89 canon_layer_cuda.cu -o canon_layer_cuda && ./canon_layer_cuda
+
+#include <cstdio>
+#include <cstdint>
+#include <vector>
+#include <cuda_runtime.h>
+
+static inline uint64_t splitmix64(uint64_t &s) {
+    s += 0x9E3779B97F4A7C15ULL;
+    uint64_t z = s;
+    z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9ULL;
+    z = (z ^ (z >> 27)) * 0x94D049BB133111EBULL;
+    return z ^ (z >> 31);
+}
+static std::vector<int8_t> genI8(size_t n, uint64_t seed) {
+    uint64_t s = seed; std::vector<int8_t> v; v.reserve(n);
+    for (size_t i = 0; i < n; i++) v.push_back((int8_t)(splitmix64(s) % 128));
+    return v;
+}
+static uint64_t fnv(const uint8_t *p, size_t n) {
+    uint64_t h = 0xcbf29ce484222325ULL;
+    for (size_t i = 0; i < n; i++) { h ^= (uint64_t)p[i]; h *= 0x100000001b3ULL; }
+    return h;
+}
+static int8_t silu_int(int32_t x) {
+    const int32_t S = 4096;
+    int32_t ax = x < 0 ? -x : x;
+    int32_t fs = (x * S) / (1 + ax);
+    int32_t sig = (fs + S) / 2;
+    int32_t silu = (x * sig) / S;
+    if (silu < -127) silu = -127; if (silu > 127) silu = 127;
+    return (int8_t)silu;
+}
+
+__global__ void layer(const int8_t *X, const int8_t *W, const int32_t *BIAS,
+                      const int32_t *M0, const int8_t *LUT, int8_t *OUT,
+                      unsigned M, unsigned K, unsigned N, unsigned shift) {
+    unsigned gid = blockIdx.x * blockDim.x + threadIdx.x;
+    if (gid >= M * N) return;
+    unsigned i = gid / N, j = gid % N;
+    int acc = 0;
+    for (unsigned t = 0; t < K; t++) acc += (int)X[i * K + t] * (int)W[t * N + j];
+    int pre = acc + BIAS[j];
+    long long round = (long long)1 << (shift - 1);
+    long long v = ((long long)pre * (long long)M0[j] + round) >> shift;
+    int q = v < -127 ? -127 : (v > 127 ? 127 : (int)v);
+    OUT[gid] = LUT[q + 128];
+}
+
+int main() {
+    const unsigned M = 16, K = 2048, N = 16, shift = 20;
+    std::vector<int8_t> x = genI8((size_t)M * K, 0x51);
+    std::vector<int8_t> w = genI8((size_t)K * N, 0x52);
+    std::vector<int32_t> bias(N), m0(N);
+    uint64_t sb = 0x53; for (unsigned j = 0; j < N; j++) bias[j] = -8300000 + (int32_t)(splitmix64(sb) % 400000);
+    uint64_t sm = 0x54; for (unsigned j = 0; j < N; j++) m0[j]   = 700     + (int32_t)(splitmix64(sm) % 200);
+    std::vector<int8_t> lut(256);
+    for (int i = 0; i < 256; i++) lut[i] = silu_int(i - 128);
+    std::vector<int8_t> out((size_t)M * N, 0);
+
+    int8_t *dX, *dW, *dL, *dO; int32_t *dB, *dM;
+    cudaMalloc(&dX, x.size()); cudaMalloc(&dW, w.size()); cudaMalloc(&dL, lut.size());
+    cudaMalloc(&dO, out.size()); cudaMalloc(&dB, N * sizeof(int32_t)); cudaMalloc(&dM, N * sizeof(int32_t));
+    cudaMemcpy(dX, x.data(), x.size(), cudaMemcpyHostToDevice);
+    cudaMemcpy(dW, w.data(), w.size(), cudaMemcpyHostToDevice);
+    cudaMemcpy(dL, lut.data(), lut.size(), cudaMemcpyHostToDevice);
+    cudaMemcpy(dB, bias.data(), N * sizeof(int32_t), cudaMemcpyHostToDevice);
+    cudaMemcpy(dM, m0.data(), N * sizeof(int32_t), cudaMemcpyHostToDevice);
+    unsigned total = M * N, tpb = 64, blocks = (total + tpb - 1) / tpb;
+    layer<<<blocks, tpb>>>(dX, dW, dB, dM, dL, dO, M, K, N, shift);
+    cudaError_t err = cudaDeviceSynchronize();
+    if (err != cudaSuccess) { printf("cuda error: %s\n", cudaGetErrorString(err)); return 1; }
+    cudaMemcpy(out.data(), dO, out.size(), cudaMemcpyDeviceToHost);
+
+    std::vector<uint8_t> ob(out.size());
+    for (size_t i = 0; i < out.size(); i++) ob[i] = (uint8_t)out[i];
+    std::vector<uint8_t> lb(lut.size());
+    for (size_t i = 0; i < lut.size(); i++) lb[i] = (uint8_t)lut[i];
+    uint64_t h = fnv(ob.data(), ob.size());
+    uint64_t lh = fnv(lb.data(), lb.size());
+    cudaDeviceProp prop; cudaGetDeviceProperties(&prop, 0);
+    printf("backend             = NVIDIA CUDA GPU (%s, sm_%d%d)\n", prop.name, prop.major, prop.minor);
+    printf("LUT   fnv           = %016llx  (target 8ab2052fcf2b005a)\n", (unsigned long long)lh);
+    printf("LAYER fnv           = %016llx  (target 440bd1b93d991fe0)\n", (unsigned long long)h);
+    printf("MATCH               = %s\n", h == 0x440bd1b93d991fe0ULL ? "OK byte-identical" : "MISMATCH");
+    return 0;
+}
diff --git a/docs/evidence/canon_layer_int.py b/docs/evidence/canon_layer_int.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8e0fb7746f5eaaf16a04812ba1c285218a4a325
--- /dev/null
+++ b/docs/evidence/canon_layer_int.py
@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+# inc4b-3 reference: FULLY-INTEGER full transformer layer (Qwen2.5-0.5B layer 0) = attention (4b-2b) +
+# SwiGLU MLP + 2nd RMSNorm + residuals. No fp on the compute path. Prints accuracy vs fp and the layer
+# fingerprint that the Rust/CUDA ports must reproduce.
+import sys, json, struct, numpy as np
+CANON = sys.argv[1] if len(sys.argv) > 1 else "/root/models/qwen05.canon"
+D, NH, NKV, HD, THETA, S, FF = 896, 14, 2, 64, 1000000.0, 4, 4864
+SC = 30; HALF = 1 << (SC-1); ALVL = 32767
+
+def qm_from_fixed(m0, shift):
+    e = shift - 1
+    return (m0 << e) if e >= 0 else ((m0 + (1 << (-e-1))) >> (-e))
+def apply(acc, sq): return (acc*sq + HALF) >> SC
+def mul(a, b): return (a*b + HALF) >> SC
+def scale_from(amax, cur): return (amax*cur)//ALVL
+def isqrt(n):
+    if n <= 0: return 0
+    x = int(n); y = (x+1)//2
+    while y < x: x = y; y = (x + int(n)//x)//2
+    return x
+def aq(v, cur):
+    amax = int(np.max(np.abs(v))) or 1
+    q = (v*ALVL*2 + np.sign(v)*amax)//(2*amax)
+    return q.astype(np.int64), scale_from(amax, cur)
+def read_canon(path):
+    f = open(path, "rb"); assert f.read(8) == b"CANONv1\n"
+    n = struct.unpack("<Q", f.read(8))[0]; hdr = json.loads(f.read(n)); body = f.read(); out = {}
+    for t in hdr["tensors"]:
+        nm, k, shp = t["name"], t["kind"], t["shape"]
+        if k == "w2d_int8_pcs":
+            o, i = shp
+            w = np.frombuffer(body[t["w_off"]:t["w_off"]+o*i], np.int8).reshape(o, i).astype(np.int64)
+            sc = np.frombuffer(body[t["s_off"]:t["s_off"]+o*8], np.int32).reshape(o, 2)
+            sq = np.array([qm_from_fixed(int(a), int(b)) for a, b in sc], object)
+            out[nm] = ("w", w, sq)
+        else:
+            v = np.frombuffer(body[t["w_off"]:t["w_off"]+shp[0]*4], np.int32).astype(np.int64)
+            m0, sh = struct.unpack("<ii", body[t["s_off"]:t["s_off"]+8]); out[nm] = ("v", v, qm_from_fixed(m0, sh))
+    return out
+T = read_canon(CANON); L = "model.layers.0."
+def imm(a, w): return a @ w.T
+inv_freq = 1.0/(THETA**(np.arange(0, HD, 2)/HD)); ang = np.outer(np.arange(S), inv_freq)
+cosF = np.concatenate([np.cos(ang)]*2, 1); sinF = np.concatenate([np.sin(ang)]*2, 1)
+cosQ = np.clip(np.rint(cosF*32768), -32768, 32767).astype(np.int64); sinQ = np.clip(np.rint(sinF*32768), -32768, 32767).astype(np.int64)
+def rope_int(xq):
+    rh = np.concatenate([-xq[..., HD//2:], xq[..., :HD//2]], -1)
+    return (xq*cosQ[:, None, :] + rh*sinQ[:, None, :] + 16384) >> 15
+def build_exp(nt=28):
+    ONE = 1 << 16; t = np.zeros(256, np.int64)
+    for d in range(256):
+        x = -d*(ONE//64); e = ONE; k = nt
+        while k >= 1: e = ONE+((x*e)//ONE)//k; k -= 1
+        t[d] = max(0, e)
+    return t
+EXP = build_exp()
+# sigmoid LUT: idx 0..4095 -> g=(idx-2048)/128, sig=sigmoid(g) in Q16 (pinned; offline fp table)
+SIG = np.clip(np.rint(1.0/(1.0+np.exp(-(np.arange(4096)-2048)/128.0))*(1 << 16)), 0, 1 << 16).astype(np.int64)
+
+Wemb, Wemb_sq = T["model.embed_tokens.weight"][1], T["model.embed_tokens.weight"][2]
+ids = [9707, 11, 1879, 30][:S]
+Xv = np.stack([Wemb[i] for i in ids]).astype(np.int64); Xsq = [int(Wemb_sq[i]) for i in ids]
+
+def rmsnorm_q(hv, gname):    # hv int [S,D], scale-invariant -> xn_q int16 [S,D], xn_sq
+    gv, gsq = T[gname][1], T[gname][2]
+    ss = np.sum(hv**2, 1); mean = ss//D + 1
+    inv = np.array([isqrt((1 << 40)//int(m)) for m in mean], np.int64)
+    yg = (hv*inv[:, None])*gv[None, :]
+    xn_q, s0 = aq(yg, 1 << SC)
+    return xn_q, mul(mul(s0, qm_from_fixed(1, 11)), int(gsq))
+def proj(wname, bname, xn_q, xn_sq):     # W8A16 int8 GEMM (+optional bias) -> int16 + scale
+    _, wv, wsq = T[wname]; acc = imm(xn_q, wv); OUT = acc.shape[1]
+    colsq = [mul(int(xn_sq), int(wsq[o])) for o in range(OUT)]
+    if bname:
+        bv, bsq = T[bname][1], int(T[bname][2])
+        bacc = np.array([(((int(bv[o])*bsq*(1 << SC)+(cs >> 1))//cs) >> SC) if (cs := colsq[o]) else 0 for o in range(OUT)], np.int64)
+    else:
+        bacc = np.zeros(OUT, np.int64)
+    accb = acc + bacc[None, :]; cmax = max(colsq)
+    resc = np.empty_like(acc)
+    for o in range(OUT): resc[:, o] = apply(accb[:, o], (colsq[o] << SC)//cmax)
+    q, sq = aq(resc.reshape(-1), cmax); return q.reshape(acc.shape), sq
+
+# ---- attention sub-block ----
+xn_q, xn_sq = rmsnorm_q(Xv, L+"input_layernorm.weight")
+qf, qsq = proj(L+"self_attn.q_proj.weight", L+"self_attn.q_proj.bias", xn_q, xn_sq)
+kf, ksq = proj(L+"self_attn.k_proj.weight", L+"self_attn.k_proj.bias", xn_q, xn_sq)
+vf, vsq = proj(L+"self_attn.v_proj.weight", L+"self_attn.v_proj.bias", xn_q, xn_sq)
+qq = rope_int(qf.reshape(S, NH, HD)); kq = rope_int(kf.reshape(S, NKV, HD)); vq = vf.reshape(S, NKV, HD)
+kq14 = np.repeat(kq, NH//NKV, 1); vq14 = np.repeat(vq, NH//NKV, 1)
+scores = np.einsum('shd,thd->hst', qq, kq14); C8 = mul(qsq, ksq)*8
+attn = np.zeros((S, D), np.int64)
+for h in range(NH):
+    for s in range(S):
+        row = scores[h, s, :s+1]; m = int(row.max())
+        d = np.clip([apply(m-int(r), C8) for r in row], 0, 255); e = EXP[np.array(d)]; den = int(e.sum())
+        for dd in range(HD):
+            acc = int(np.sum(e*vq14[:s+1, h, dd]))
+            attn[s, h*HD+dd] = ((acc*(1 << SC)+(den >> 1))//den) >> SC
+aqa, aqa_sq = aq(attn.reshape(-1), vsq); aqa = aqa.reshape(S, D)
+_, wo, wosq = T[L+"self_attn.o_proj.weight"]; oacc = imm(aqa, wo)
+ocsq = [mul(int(aqa_sq), int(wosq[dd])) for dd in range(D)]
+hout = np.zeros((S, D), np.int64)
+for s in range(S):
+    for dd in range(D): hout[s, dd] = Xv[s, dd] + apply(int(oacc[s, dd]), (ocsq[dd] << SC)//Xsq[s])
+
+# ---- SwiGLU MLP sub-block ----
+xn2_q, xn2_sq = rmsnorm_q(hout, L+"post_attention_layernorm.weight")
+gate_q, gate_sq = proj(L+"mlp.gate_proj.weight", None, xn2_q, xn2_sq)   # [S,FF]
+up_q, up_sq = proj(L+"mlp.up_proj.weight", None, xn2_q, xn2_sq)
+# SiLU: act = gate * sigmoid(gate).  idx = round(gate_true*128)+2048
+idx = np.clip(apply(gate_q, int(gate_sq) << 7) + 2048, 0, 4095)
+sig = SIG[idx]                                   # Q16
+act_int = gate_q*sig                             # int (large ~2^31)
+# requant act to int16; scale = scale_from(amax, gate_sq) >> 16  (>>16 for the Q16 sigmoid; large amax first)
+act_q, spre = aq(act_int.reshape(-1), int(gate_sq)); act_q = act_q.reshape(S, FF)
+act_sq = spre >> 16
+hmul = act_q*up_q                                # int
+hmul_sq = mul(int(act_sq), int(up_sq))
+hmul_q, hmul_q_sq = aq(hmul.reshape(-1), hmul_sq); hmul_q = hmul_q.reshape(S, FF)
+mlp_q, mlp_sq = proj(L+"mlp.down_proj.weight", None, hmul_q, hmul_q_sq)   # [S,D]
+layer = np.zeros((S, D), np.int64)   # mlp residual: bring mlp (scale mlp_sq) into hout's per-token Xsq scale
+for s in range(S):
+    ratio = (int(mlp_sq) << SC)//Xsq[s]
+    for dd in range(D): layer[s, dd] = hout[s, dd] + apply(int(mlp_q[s, dd]), ratio)
+
+def fnv(b):
+    h = 0xcbf29ce484222325
+    for x in b: h = ((h ^ (x & 0xff))*0x100000001b3) & 0xFFFFFFFFFFFFFFFF
+    return h
+fp = fnv(layer.astype(np.int64).tobytes())
+
+# ---- fp reference (full layer) ----
+def wd(n): _, w, s = T[n]; return w.astype(np.float64) * np.array([int(s[o])/(1 << SC) for o in range(w.shape[0])])[:, None]
+def vd(n): _, v, s = T[n]; return v.astype(np.float64) * (int(s)/(1 << SC))
+Xfp = Xv.astype(np.float64)*np.array(Xsq)[:, None]/(1 << SC)
+def rms_fp(h, g): return h/np.sqrt(np.mean(h*h, 1, keepdims=True)+1e-6)*g
+xn = rms_fp(Xfp, vd(L+"input_layernorm.weight"))
+Wq, Wk, Wv, Wo = wd(L+"self_attn.q_proj.weight"), wd(L+"self_attn.k_proj.weight"), wd(L+"self_attn.v_proj.weight"), wd(L+"self_attn.o_proj.weight")
+bq, bk, bv = vd(L+"self_attn.q_proj.bias"), vd(L+"self_attn.k_proj.bias"), vd(L+"self_attn.v_proj.bias")
+q = (xn@Wq.T+bq).reshape(S, NH, HD); k = (xn@Wk.T+bk).reshape(S, NKV, HD); v = (xn@Wv.T+bv).reshape(S, NKV, HD)
+rhf = lambda x: np.concatenate([-x[..., HD//2:], x[..., :HD//2]], -1)
+q = q*cosF[:, None, :]+rhf(q)*sinF[:, None, :]; k = k*cosF[:, None, :]+rhf(k)*sinF[:, None, :]
+k14 = np.repeat(k, NH//NKV, 1); v14 = np.repeat(v, NH//NKV, 1); sc = np.einsum('shd,thd->hst', q, k14)/np.sqrt(HD)
+for h in range(NH):
+    for s in range(S): sc[h, s, s+1:] = -1e30
+af = np.zeros((S, NH, HD))
+for h in range(NH):
+    p = np.exp(sc[h]-sc[h].max(1, keepdims=True)); p /= p.sum(1, keepdims=True); af[:, h, :] = p@v14[:, h, :]
+hfp = Xfp + af.reshape(S, D)@Wo.T
+xn2 = rms_fp(hfp, vd(L+"post_attention_layernorm.weight"))
+g = xn2@wd(L+"mlp.gate_proj.weight").T; u = xn2@wd(L+"mlp.up_proj.weight").T
+silu = g/(1.0+np.exp(-g)); mlp = (silu*u)@wd(L+"mlp.down_proj.weight").T
+layer_fp = hfp + mlp
+layer_int_fp = layer.astype(np.float64)*np.array(Xsq)[:, None]/(1 << SC)
+rel = float(np.sqrt(np.sum((layer_int_fp-layer_fp)**2)/np.sum(layer_fp**2)))
+print(f"FULL LAYER: accuracy vs fp = {rel:.4f}")
+print(f"layer-out FNV = {fp:016x}   <- Rust/CUDA ports must reproduce")
+print(f"layer[0,:4] int = {layer[0,:4]}")
diff --git a/docs/evidence/canon_layer_metal.swift b/docs/evidence/canon_layer_metal.swift
new file mode 100644
index 0000000000000000000000000000000000000000..5854ff85abe5c2c3df040526bc8515cd1f261d09
--- /dev/null
+++ b/docs/evidence/canon_layer_metal.swift
@@ -0,0 +1,94 @@
+// Canonical integer LAYER on Apple Metal GPU (increment 3). Must reproduce the CPU fingerprints:
+//   LAYER fnv = 440bd1b93d991fe0 , LUT fnv = 8ab2052fcf2b005a
+// Build/run:  swiftc -O canon_layer_metal.swift -o canon_layer_metal && ./canon_layer_metal
+
+import Foundation
+import Metal
+
+func splitmix64(_ s: inout UInt64) -> UInt64 {
+    s = s &+ 0x9E3779B97F4A7C15
+    var z = s
+    z = (z ^ (z >> 30)) &* 0xBF58476D1CE4E5B9
+    z = (z ^ (z >> 27)) &* 0x94D049BB133111EB
+    return z ^ (z >> 31)
+}
+func genI8(_ n: Int, _ seed: UInt64) -> [Int8] {
+    var s = seed; var v = [Int8](); v.reserveCapacity(n)
+    for _ in 0..<n { v.append(Int8(splitmix64(&s) % 128)) }
+    return v
+}
+func fnv(_ bytes: [UInt8]) -> UInt64 {
+    var h: UInt64 = 0xcbf29ce484222325
+    for b in bytes { h ^= UInt64(b); h = h &* 0x100000001b3 }
+    return h
+}
+func siluInt(_ x: Int32) -> Int8 {
+    let S: Int32 = 4096
+    let ax = abs(x)
+    let fs = (x &* S) / (1 + ax)
+    let sig = (fs + S) / 2
+    let silu = (x &* sig) / S
+    return Int8(max(-127, min(127, silu)))
+}
+
+let M = 16, K = 2048, N = 16
+let shift: UInt32 = 20
+let x = genI8(M * K, 0x51)
+let w = genI8(K * N, 0x52)
+var sb: UInt64 = 0x53
+let bias: [Int32] = (0..<N).map { _ in Int32(-8_300_000) &+ Int32(splitmix64(&sb) % 400_000) }
+var sm: UInt64 = 0x54
+let m0: [Int32] = (0..<N).map { _ in Int32(700) &+ Int32(splitmix64(&sm) % 200) }
+var lut = [Int8](repeating: 0, count: 256)
+for i in 0..<256 { lut[i] = siluInt(Int32(i) - 128) }
+
+let shader = """
+#include <metal_stdlib>
+using namespace metal;
+kernel void layer(device const char* X    [[buffer(0)]],
+                  device const char* W    [[buffer(1)]],
+                  device const int*  BIAS [[buffer(2)]],
+                  device const int*  M0   [[buffer(3)]],
+                  device const char* LUT  [[buffer(4)]],
+                  device char*       OUT  [[buffer(5)]],
+                  constant uint4&    dims [[buffer(6)]],
+                  uint gid [[thread_position_in_grid]]) {
+    uint Mv=dims.x, Kv=dims.y, Nv=dims.z, sh=dims.w;
+    if (gid >= Mv*Nv) return;
+    uint i = gid / Nv, j = gid % Nv;
+    int acc = 0;
+    for (uint t = 0; t < Kv; t++) acc += int(X[i*Kv+t]) * int(W[t*Nv+j]);
+    int pre = acc + BIAS[j];
+    long round = (long)1 << (sh - 1);
+    long v = ((long)pre * (long)M0[j] + round) >> sh;
+    int q = v < -127 ? -127 : (v > 127 ? 127 : (int)v);
+    OUT[gid] = LUT[q + 128];
+}
+"""
+
+guard let dev = MTLCreateSystemDefaultDevice() else { fatalError("no Metal device") }
+let lib = try! dev.makeLibrary(source: shader, options: nil)
+let pipe = try! dev.makeComputePipelineState(function: lib.makeFunction(name: "layer")!)
+let q = dev.makeCommandQueue()!
+func buf<T>(_ arr: [T]) -> MTLBuffer { dev.makeBuffer(bytes: arr, length: MemoryLayout<T>.stride * arr.count, options: .storageModeShared)! }
+let bX = buf(x), bW = buf(w), bB = buf(bias), bM = buf(m0), bL = buf(lut)
+let bOut = dev.makeBuffer(length: M * N, options: .storageModeShared)!
+var dims = SIMD4<UInt32>(UInt32(M), UInt32(K), UInt32(N), shift)
+let bD = dev.makeBuffer(bytes: &dims, length: MemoryLayout<SIMD4<UInt32>>.size, options: .storageModeShared)!
+
+let cmd = q.makeCommandBuffer()!
+let enc = cmd.makeComputeCommandEncoder()!
+enc.setComputePipelineState(pipe)
+for (idx, b) in [bX, bW, bB, bM, bL, bOut, bD].enumerated() { enc.setBuffer(b, offset: 0, index: idx) }
+enc.dispatchThreads(MTLSize(width: M * N, height: 1, depth: 1), threadsPerThreadgroup: MTLSize(width: 64, height: 1, depth: 1))
+enc.endEncoding(); cmd.commit(); cmd.waitUntilCompleted()
+
+let optr = bOut.contents().bindMemory(to: Int8.self, capacity: M * N)
+var outBytes = [UInt8](); outBytes.reserveCapacity(M * N)
+for i in 0..<(M * N) { outBytes.append(UInt8(bitPattern: optr[i])) }
+let h = fnv(outBytes)
+let lutH = fnv(lut.map { UInt8(bitPattern: $0) })
+print("backend             = Apple Metal GPU (\(dev.name))")
+print(String(format: "LUT   fnv           = %016llx  (target 8ab2052fcf2b005a)", lutH))
+print(String(format: "LAYER fnv           = %016llx  (target 440bd1b93d991fe0)", h))
+print("MATCH               = \(String(format: "%016llx", h) == "440bd1b93d991fe0" ? "✅ byte-identical to CPU" : "❌ MISMATCH")")
diff --git a/docs/evidence/canon_metal.swift b/docs/evidence/canon_metal.swift
new file mode 100644
index 0000000000000000000000000000000000000000..ac71120d17fb78afcc2d4029c3c4c613b49fe787
--- /dev/null
+++ b/docs/evidence/canon_metal.swift
@@ -0,0 +1,93 @@
+// Canonical int8 GEMM on Apple Metal GPU — must reproduce the CPU/x86 canonical fingerprint.
+// Same splitmix64 inputs + same int32 GEMM as canon_int.rs (M,K,N = 32,8192,32, values 0..127).
+// Target INT fnv (from CPU aarch64 & x86_64): 4b138ed70d137781
+//
+// Build/run:  swiftc -O canon_metal.swift -o canon_metal && ./canon_metal
+
+import Foundation
+import Metal
+
+// ---- identical deterministic input generation ----
+func splitmix64(_ s: inout UInt64) -> UInt64 {
+    s = s &+ 0x9E3779B97F4A7C15
+    var z = s
+    z = (z ^ (z >> 30)) &* 0xBF58476D1CE4E5B9
+    z = (z ^ (z >> 27)) &* 0x94D049BB133111EB
+    return z ^ (z >> 31)
+}
+func genI8(_ n: Int, _ seed: UInt64) -> [Int8] {
+    var s = seed
+    var v = [Int8](); v.reserveCapacity(n)
+    for _ in 0..<n { v.append(Int8(splitmix64(&s) % 128)) }
+    return v
+}
+func fnv(_ bytes: [UInt8]) -> UInt64 {
+    var h: UInt64 = 0xcbf29ce484222325
+    for b in bytes { h ^= UInt64(b); h = h &* 0x100000001b3 }
+    return h
+}
+
+let M = 32, K = 8192, N = 32
+let a = genI8(M * K, 0xA11CE)          // weights, row-major M×K
+let b = genI8(K * N, 0xB0B)            // activations, row-major K×N
+
+let shader = """
+#include <metal_stdlib>
+using namespace metal;
+kernel void gemm_i8(device const char*  A     [[buffer(0)]],
+                    device const char*  B     [[buffer(1)]],
+                    device int*         C     [[buffer(2)]],
+                    constant uint3&     dims  [[buffer(3)]],
+                    uint gid [[thread_position_in_grid]]) {
+    uint Mv = dims.x, Kv = dims.y, Nv = dims.z;
+    if (gid >= Mv * Nv) return;
+    uint i = gid / Nv, j = gid % Nv;
+    int acc = 0;                                  // int32 accumulation
+    for (uint t = 0; t < Kv; t++) {
+        acc += int(A[i * Kv + t]) * int(B[t * Nv + j]);
+    }
+    C[gid] = acc;
+}
+"""
+
+guard let dev = MTLCreateSystemDefaultDevice() else { fatalError("no Metal device") }
+let lib = try! dev.makeLibrary(source: shader, options: nil)
+let fn = lib.makeFunction(name: "gemm_i8")!
+let pipe = try! dev.makeComputePipelineState(function: fn)
+let q = dev.makeCommandQueue()!
+
+let bufA = dev.makeBuffer(bytes: a, length: a.count, options: .storageModeShared)!
+let bufB = dev.makeBuffer(bytes: b, length: b.count, options: .storageModeShared)!
+let bufC = dev.makeBuffer(length: M * N * MemoryLayout<Int32>.size, options: .storageModeShared)!
+var dims = SIMD3<UInt32>(UInt32(M), UInt32(K), UInt32(N))
+let bufD = dev.makeBuffer(bytes: &dims, length: MemoryLayout<SIMD3<UInt32>>.size, options: .storageModeShared)!
+
+let cmd = q.makeCommandBuffer()!
+let enc = cmd.makeComputeCommandEncoder()!
+enc.setComputePipelineState(pipe)
+enc.setBuffer(bufA, offset: 0, index: 0)
+enc.setBuffer(bufB, offset: 0, index: 1)
+enc.setBuffer(bufC, offset: 0, index: 2)
+enc.setBuffer(bufD, offset: 0, index: 3)
+let total = M * N
+let tpg = 64
+enc.dispatchThreads(MTLSize(width: total, height: 1, depth: 1),
+                    threadsPerThreadgroup: MTLSize(width: tpg, height: 1, depth: 1))
+enc.endEncoding()
+cmd.commit()
+cmd.waitUntilCompleted()
+
+// read back C as int32, serialize little-endian, FNV
+let cptr = bufC.contents().bindMemory(to: Int32.self, capacity: total)
+var bytes = [UInt8](); bytes.reserveCapacity(total * 4)
+for idx in 0..<total {
+    let v = UInt32(bitPattern: cptr[idx])
+    bytes.append(UInt8(v & 0xff)); bytes.append(UInt8((v >> 8) & 0xff))
+    bytes.append(UInt8((v >> 16) & 0xff)); bytes.append(UInt8((v >> 24) & 0xff))
+}
+let h = fnv(bytes)
+print("backend             = Apple Metal GPU (\(dev.name))")
+print("shape M,K,N         = \(M),\(K),\(N)")
+print(String(format: "INT  gpu  fnv       = %016llx", h))
+print("TARGET (CPU)        = 4b138ed70d137781")
+print("MATCH               = \(String(format: "%016llx", h) == "4b138ed70d137781" ? "✅ byte-identical to CPU" : "❌ MISMATCH")")
diff --git a/docs/evidence/canon_model.cu b/docs/evidence/canon_model.cu
new file mode 100644
index 0000000000000000000000000000000000000000..51510233815f8abee97b3169fd3ffa8aeed6de8b
--- /dev/null
+++ b/docs/evidence/canon_model.cu
@@ -0,0 +1,149 @@
+// Full-model canonical integer forward (hifi: W8A24, Q60, 1/512 LUTs) — CUDA run.
+// ALL GEMMs (q/k/v/o/gate/up/down per layer + tied LM head — the compute-dominant ops) execute ON THE GPU
+// (one thread per output element, sequential k-loop → bit-exact). Integer glue (scales/aq/softmax/rope/
+// residuals) runs on host with __int128 — every step integer, so the whole forward is deterministic.
+// Must reproduce: [3555, 374, 279, 7290, 315, 279].
+// Build: nvcc -O3 -arch=sm_89 canon_model.cu -o canon_model_cu && ./canon_model_cu model.bin 6
+#include <cstdio>
+#include <cstdint>
+#include <vector>
+#include <cstring>
+#include <cuda_runtime.h>
+typedef long long i64; typedef __int128 i128;
+static const unsigned SC=60; static const i128 HALF=(i128)1<<59, ALVL=((i128)1<<23)-1;
+static const int D=896, NH=14, NKV=2, HD=64, FF=4864, NL=24, VOCAB=151936;
+
+static i128 qm(i64 m0,i64 sh){ i64 e=sh-31+(i64)SC; return e>=0?((i128)m0<<e):(((i128)m0+((i128)1<<(-e-1)))>>(-e)); }
+static i128 ap(i128 a,i128 s){ return (a*s+HALF)>>SC; }
+static i128 mul(i128 a,i128 b){ return (a*b+HALF)>>SC; }
+static i128 fdiv(i128 a,i128 b){ i128 q=a/b,r=a%b; if(r!=0&&((r<0)!=(b<0)))return q-1; return q; }
+static i128 isqrt(i128 n){ if(n<=0)return 0; i128 x=n,y=(x+1)/2; while(y<x){x=y;y=(x+n/x)/2;} return x; }
+static i128 aq(std::vector<i64>& v,i128 cur){ i64 am=1; for(i64 x:v){i64 a=x<0?-x:x; if(a>am)am=a;} i128 amc=am;
+  for(auto& x:v){ i128 xi=x, sg=xi>0?amc:(xi<0?-amc:0); x=(i64)fdiv(xi*ALVL*2+sg,2*amc);} return (amc*cur)/ALVL; }
+
+struct Buf{ std::vector<unsigned char> b; long p=0;
+  unsigned u32(){unsigned v;memcpy(&v,&b[p],4);p+=4;return v;} int i32(){int v;memcpy(&v,&b[p],4);p+=4;return v;}
+  i64 i64_(){i64 v;memcpy(&v,&b[p],8);p+=8;return v;} unsigned char u8(){return b[p++];} };
+struct W2d{ int rows,cols; signed char* dw; std::vector<i128> sq; };  // weights live on DEVICE
+struct V1d{ std::vector<i64> v; i128 sq; };
+static W2d rd_w2d(Buf& b){ b.u8(); int r=b.u32(),c=b.u32(); signed char* d; cudaMalloc(&d,(size_t)r*c);
+  cudaMemcpy(d,&b.b[b.p],(size_t)r*c,cudaMemcpyHostToDevice); b.p+=(long)r*c;
+  int ns=b.u32(); std::vector<i128> sq(ns); for(int i=0;i<ns;i++){i64 m=b.i32(),s=b.i32(); sq[i]=qm(m,s);} return W2d{r,c,d,sq}; }
+static V1d rd_v1d(Buf& b){ b.u8(); int n=b.u32(); b.u32(); std::vector<i64> v(n); for(int i=0;i<n;i++)v[i]=b.i32();
+  b.u32(); i64 m=b.i32(),s=b.i32(); return V1d{v,qm(m,s)}; }
+
+__global__ void k_gemm(const i64* x,const signed char* w,i64* out,int S,int OC,int K){
+  int idx=blockIdx.x*blockDim.x+threadIdx.x; if(idx>=S*OC) return;
+  int s=idx/OC,o=idx%OC; i64 a=0; const signed char* wr=w+(size_t)o*K; const i64* xr=x+(size_t)s*K;
+  for(int d=0;d<K;d++) a+=xr[d]*(i64)wr[d]; out[idx]=a;
+}
+static i64 *g_dx,*g_dout; static size_t g_cx=0,g_co=0;
+static void gemm(const std::vector<i64>& x,const W2d& w,int S,std::vector<i64>& out){
+  size_t nx=(size_t)S*w.cols, no=(size_t)S*w.rows;
+  if(nx>g_cx){ if(g_dx)cudaFree(g_dx); cudaMalloc(&g_dx,nx*8); g_cx=nx; }
+  if(no>g_co){ if(g_dout)cudaFree(g_dout); cudaMalloc(&g_dout,no*8); g_co=no; }
+  cudaMemcpy(g_dx,x.data(),nx*8,cudaMemcpyHostToDevice);
+  int tpb=256, blocks=(int)((no+tpb-1)/tpb);
+  k_gemm<<<blocks,tpb>>>(g_dx,w.dw,g_dout,S,w.rows,w.cols);
+  out.resize(no); cudaMemcpy(out.data(),g_dout,no*8,cudaMemcpyDeviceToHost);
+}
+
+struct Layer{ V1d ln1; W2d qw; V1d qb; W2d kw; V1d kb; W2d vw; V1d vb; W2d ow; V1d ln2; W2d gw,uw,dw; };
+static std::vector<i64> COSQ,SINQ,EXPL,SIGL;
+
+static void rmsnorm(const std::vector<i64>& hv,int S,const V1d& g,std::vector<i64>& q,i128& sq){
+  std::vector<i64> yg((size_t)S*D);
+  for(int s=0;s<S;s++){ i128 ss=0; for(int d=0;d<D;d++){i128 x=hv[(size_t)s*D+d]; ss+=x*x;}
+    i64 inv=(i64)isqrt(((i128)1<<40)/(ss/D+1));
+    for(int d=0;d<D;d++) yg[(size_t)s*D+d]=hv[(size_t)s*D+d]*inv*g.v[d]; }
+  i128 s0=aq(yg,(i128)1<<SC); q=yg; sq=mul(mul(s0,qm(1,11)),g.sq);
+}
+static void proj(const W2d& w,const V1d* b,int S,const std::vector<i64>& xnq,i128 xnsq,std::vector<i64>& out,i128& osq){
+  std::vector<i64> acc; gemm(xnq,w,S,acc);
+  int oc=w.rows; std::vector<i128> colsq(oc); i128 cmax=0;
+  for(int o=0;o<oc;o++){ colsq[o]=mul(xnsq,w.sq[o]); if(colsq[o]>cmax)cmax=colsq[o]; }
+  out.assign((size_t)S*oc,0);
+  for(int o=0;o<oc;o++){ i64 bacc=0; if(b){ i128 cs=colsq[o]; if(cs) bacc=(i64)(fdiv((i128)b->v[o]*b->sq*((i128)1<<SC)+(cs>>1),cs)>>SC); }
+    i128 r=(colsq[o]<<SC)/cmax;
+    for(int s=0;s<S;s++) out[(size_t)s*oc+o]=(i64)ap((i128)acc[(size_t)s*oc+o]+bacc,r); }
+  osq=aq(out,cmax);
+}
+static void rope(std::vector<i64>& x,int S,int nh){
+  std::vector<i64> src=x;
+  for(int s=0;s<S;s++)for(int h=0;h<nh;h++)for(int d=0;d<HD;d++){ size_t base=((size_t)s*nh+h)*HD;
+    i64 rh=d<HD/2?-src[base+d+HD/2]:src[base+d-HD/2];
+    x[base+d]=(src[base+d]*COSQ[(size_t)s*HD+d]+rh*SINQ[(size_t)s*HD+d]+16384)>>15; }
+}
+
+int main(int argc,char** argv){
+  const char* path=argc>1?argv[1]:"model.bin"; int ndecode=argc>2?atoi(argv[2]):6;
+  FILE* f=fopen(path,"rb"); fseek(f,0,SEEK_END); long n=ftell(f); fseek(f,0,SEEK_SET);
+  Buf b; b.b.resize(n); size_t rd=fread(b.b.data(),1,n,f); (void)rd; fclose(f);
+  if(memcmp(b.b.data(),"QCM0\0\0\0\0",8)){printf("bad magic\n");return 1;} b.p=8;
+  int nl=b.u32(); int smax=b.u32(); (void)nl;
+  W2d emb=rd_w2d(b);
+  std::vector<Layer> L; L.reserve(NL);
+  for(int l=0;l<NL;l++){ Layer y{rd_v1d(b),rd_w2d(b),rd_v1d(b),rd_w2d(b),rd_v1d(b),rd_w2d(b),rd_v1d(b),rd_w2d(b),rd_v1d(b),rd_w2d(b),rd_w2d(b),rd_w2d(b)}; L.push_back(std::move(y)); }
+  V1d fnorm=rd_v1d(b);
+  COSQ.resize((size_t)smax*HD); SINQ.resize((size_t)smax*HD); EXPL.resize(2048); SIGL.resize(16384);
+  for(auto* a:{&COSQ,&SINQ}) for(auto& x:*a) x=b.i64_();
+  for(auto& x:EXPL) x=b.i64_(); for(auto& x:SIGL) x=b.i64_();
+  // keep host copy of embedding int8 for gather (device copy used for LM head gemm)
+  // re-read embed weights from file region: simpler — gather via device? do a host copy path:
+  // (emb weights already uploaded; for the gather we re-read from the file buffer)
+  // embed record starts at offset 8+8: kind(1)+rows(4)+cols(4)=9 bytes header → weights at 25
+  const signed char* embh=(const signed char*)&b.b[8+8+9];
+
+  std::vector<int> prompt={9707,11,1879,30}, toks=prompt, gen;
+  for(int step=0; step<ndecode; step++){
+    int S=(int)toks.size();
+    std::vector<i64> hv((size_t)S*D); std::vector<i128> xsq(S);
+    for(int s=0;s<S;s++){ int t=toks[s]; for(int d=0;d<D;d++) hv[(size_t)s*D+d]=embh[(size_t)t*D+d]; xsq[s]=emb.sq[t]; }
+    for(auto& l:L){
+      std::vector<i64> xnq; i128 xnsq; rmsnorm(hv,S,l.ln1,xnq,xnsq);
+      std::vector<i64> qq,kq,vq; i128 qsq,ksq,vsq;
+      proj(l.qw,&l.qb,S,xnq,xnsq,qq,qsq); proj(l.kw,&l.kb,S,xnq,xnsq,kq,ksq); proj(l.vw,&l.vb,S,xnq,xnsq,vq,vsq);
+      rope(qq,S,NH); rope(kq,S,NKV);
+      int g=NH/NKV; i128 c512=mul(qsq,ksq)*64;
+      std::vector<i64> attn((size_t)S*D,0);
+      for(int h=0;h<NH;h++){ int kvh=h/g; for(int s=0;s<S;s++){
+        std::vector<i64> sc(s+1); i64 m=INT64_MIN;
+        for(int t=0;t<=s;t++){ i64 a=0; for(int d=0;d<HD;d++) a+=qq[((size_t)s*NH+h)*HD+d]*kq[((size_t)t*NKV+kvh)*HD+d]; sc[t]=a; if(a>m)m=a; }
+        std::vector<i64> e(s+1); i128 den=0;
+        for(int t=0;t<=s;t++){ i128 dd=ap((i128)(m-sc[t]),c512); if(dd<0)dd=0; if(dd>2047)dd=2047; e[t]=EXPL[(int)dd]; den+=e[t]; }
+        for(int d=0;d<HD;d++){ i128 acc=0; for(int t=0;t<=s;t++) acc+=(i128)e[t]*vq[((size_t)t*NKV+kvh)*HD+d];
+          attn[(size_t)s*D+h*HD+d]=(i64)(fdiv(acc*((i128)1<<SC)+(den>>1),den)>>SC); } } }
+      i128 aqsq=aq(attn,vsq);
+      std::vector<i64> oacc; gemm(attn,l.ow,S,oacc);
+      std::vector<i64> hout((size_t)S*D);
+      for(int s=0;s<S;s++)for(int d2=0;d2<D;d2++){ i128 oc=mul(aqsq,l.ow.sq[d2]);
+        hout[(size_t)s*D+d2]=hv[(size_t)s*D+d2]+(i64)ap((i128)oacc[(size_t)s*D+d2],(oc<<SC)/xsq[s]); }
+      std::vector<i64> xn2q; i128 xn2sq; rmsnorm(hout,S,l.ln2,xn2q,xn2sq);
+      std::vector<i64> gate,up; i128 gsq,usq;
+      proj(l.gw,nullptr,S,xn2q,xn2sq,gate,gsq); proj(l.uw,nullptr,S,xn2q,xn2sq,up,usq);
+      i128 gs9=gsq<<9;
+      std::vector<i64> act((size_t)S*FF);
+      for(size_t i=0;i<(size_t)S*FF;i++){ i128 idx=((i128)gate[i]*gs9+HALF)>>SC; idx+=8192; if(idx<0)idx=0; if(idx>16383)idx=16383; act[i]=gate[i]*SIGL[(int)idx]; }
+      i128 spre=aq(act,gsq); i128 asq=spre>>16;
+      std::vector<i64> hm((size_t)S*FF);
+      for(size_t i=0;i<(size_t)S*FF;i++) hm[i]=act[i]*up[i];
+      i128 hsq=aq(hm,mul(asq,usq));
+      std::vector<i64> mlp; i128 msq; proj(l.dw,nullptr,S,hm,hsq,mlp,msq);
+      for(int s=0;s<S;s++){ i128 r=(msq<<SC)/xsq[s]; for(int d2=0;d2<D;d2++) hv[(size_t)s*D+d2]=hout[(size_t)s*D+d2]+(i64)ap((i128)mlp[(size_t)s*D+d2],r); }
+    }
+    std::vector<i64> xnq; i128 xnsq; rmsnorm(hv,S,fnorm,xnq,xnsq); (void)xnsq;
+    std::vector<i64> last(xnq.end()-D,xnq.end());
+    std::vector<i64> raw; gemm(last,emb,1,raw);         // LM head on GPU: [1,VOCAB]
+    int best=0; i128 bv=-(((i128)1)<<126);
+    for(int v=0;v<VOCAB;v++){ i128 sc=((i128)raw[v]*emb.sq[v]+HALF)>>SC; if(sc>bv){bv=sc;best=v;} }
+    gen.push_back(best); toks.push_back(best);
+  }
+  cudaDeviceProp pr; cudaGetDeviceProperties(&pr,0);
+  printf("backend   = CUDA GEMMs on %s (sm_%d%d) + host int128 glue\n",pr.name,pr.major,pr.minor);
+  printf("generated = ["); for(size_t i=0;i<gen.size();i++) printf("%d%s",gen[i],i+1<gen.size()?", ":""); printf("]\n");
+  unsigned long long h=0xcbf29ce484222325ULL;
+  for(int t:gen){ i64 v=t; unsigned char* p=(unsigned char*)&v; for(int k=0;k<8;k++){h^=p[k];h*=0x100000001b3ULL;} }
+  printf("ids FNV   = %016llx\n",h);
+  printf("EXPECTED  = [3555, 374, 279, 7290, 315, 279] / FNV 65d2e3adaf2dce9e\n");
+  return 0;
+}
diff --git a/docs/evidence/canon_model.rs b/docs/evidence/canon_model.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bc5f1c971106cd21498ab8d9ad96f1376076d6d5
--- /dev/null
+++ b/docs/evidence/canon_model.rs
@@ -0,0 +1,188 @@
+// Full-model canonical integer forward (hifi: W8A24, Q60 scales, 1/512 LUTs) — Rust port.
+// Reads model.bin, greedy-decodes NDECODE tokens, prints token ids + FNV over ids.
+// Must reproduce the Python reference: [3555, 374, 279, 7290, 315, 279] for prompt [9707,11,1879,30].
+// Build/run: rustc -O --edition 2021 canon_model.rs -o canon_model && ./canon_model model.bin 6
+
+use std::io::Read;
+
+const SC: u32 = 60;
+const HALF: i128 = 1 << 59;
+const ALVL: i128 = (1 << 23) - 1;
+const D: usize = 896;
+const NH: usize = 14;
+const NKV: usize = 2;
+const HD: usize = 64;
+const FF: usize = 4864;
+const NL: usize = 24;
+const VOCAB: usize = 151936;
+
+fn qm(m0: i64, sh: i64) -> i128 { let e = sh - 31 + SC as i64; if e >= 0 { (m0 as i128) << e } else { ((m0 as i128) + (1i128 << (-e - 1))) >> (-e) } }
+fn apply(a: i128, s: i128) -> i128 { (a * s + HALF) >> SC }
+fn mul(a: i128, b: i128) -> i128 { (a * b + HALF) >> SC }
+fn sfrom(amax: i128, cur: i128) -> i128 { (amax * cur) / ALVL }
+fn fdiv(a: i128, b: i128) -> i128 { let q = a / b; let r = a % b; if r != 0 && (r < 0) != (b < 0) { q - 1 } else { q } }
+fn isqrt(n: i128) -> i128 { if n <= 0 { return 0; } let mut x = n; let mut y = (x + 1) / 2; while y < x { x = y; y = (x + n / x) / 2; } x }
+fn aq(v: &[i64], cur: i128) -> (Vec<i64>, i128) {
+    let am = v.iter().map(|x| x.abs()).max().unwrap().max(1) as i128;
+    let q = v.iter().map(|&x| { let xi = x as i128; let sg = if xi > 0 { am } else if xi < 0 { -am } else { 0 }; fdiv(xi * ALVL * 2 + sg, 2 * am) as i64 }).collect();
+    (q, sfrom(am, cur))
+}
+fn fnv(bytes: &[u8]) -> u64 { let mut h = 0xcbf29ce484222325u64; for &b in bytes { h ^= b as u64; h = h.wrapping_mul(0x100000001b3); } h }
+
+struct Cur<'a> { b: &'a [u8], p: usize }
+impl<'a> Cur<'a> {
+    fn u8(&mut self) -> u8 { let v = self.b[self.p]; self.p += 1; v }
+    fn u32(&mut self) -> u32 { let v = u32::from_le_bytes(self.b[self.p..self.p + 4].try_into().unwrap()); self.p += 4; v }
+    fn i32(&mut self) -> i32 { let v = i32::from_le_bytes(self.b[self.p..self.p + 4].try_into().unwrap()); self.p += 4; v }
+    fn i64(&mut self) -> i64 { let v = i64::from_le_bytes(self.b[self.p..self.p + 8].try_into().unwrap()); self.p += 8; v }
+}
+struct W2d { rows: usize, cols: usize, w: Vec<i8>, sq: Vec<i128> }
+struct V1d { v: Vec<i64>, sq: i128 }
+fn rd_w2d(c: &mut Cur) -> W2d {
+    assert_eq!(c.u8(), 0); let rows = c.u32() as usize; let cols = c.u32() as usize;
+    let w: Vec<i8> = (0..rows * cols).map(|_| c.u8() as i8).collect();
+    let ns = c.u32() as usize; let sq = (0..ns).map(|_| { let m0 = c.i32() as i64; let sh = c.i32() as i64; qm(m0, sh) }).collect();
+    W2d { rows, cols, w, sq }
+}
+fn rd_v1d(c: &mut Cur) -> V1d {
+    assert_eq!(c.u8(), 1); let n = c.u32() as usize; let _ = c.u32();
+    let v: Vec<i64> = (0..n).map(|_| c.i32() as i64).collect();
+    let _ = c.u32(); let m0 = c.i32() as i64; let sh = c.i32() as i64;
+    V1d { v, sq: qm(m0, sh) }
+}
+struct Layer { ln1: V1d, qw: W2d, qb: V1d, kw: W2d, kb: V1d, vw: W2d, vb: V1d, ow: W2d, ln2: V1d, gw: W2d, uw: W2d, dw: W2d }
+
+fn rmsnorm(hv: &[i64], s: usize, gam: &V1d) -> (Vec<i64>, i128) {
+    let mut yg = vec![0i64; s * D];
+    for si in 0..s {
+        let ss: i128 = (0..D).map(|d| { let x = hv[si * D + d] as i128; x * x }).sum();
+        let mean = ss / (D as i128) + 1;
+        let inv = isqrt((1i128 << 40) / mean) as i64;
+        for d in 0..D { yg[si * D + d] = hv[si * D + d] * inv * gam.v[d]; }
+    }
+    let (q, s0) = aq(&yg, 1i128 << SC);
+    (q, mul(mul(s0, qm(1, 11)), gam.sq))
+}
+fn proj(w: &W2d, b: Option<&V1d>, s: usize, xn_q: &[i64], xn_sq: i128) -> (Vec<i64>, i128) {
+    let (oc, inn) = (w.rows, w.cols);
+    let mut acc = vec![0i64; s * oc];
+    for si in 0..s { for o in 0..oc { let mut a = 0i64; let base = o * inn; for d in 0..inn { a += xn_q[si * inn + d] * (w.w[base + d] as i64); } acc[si * oc + o] = a; } }
+    let colsq: Vec<i128> = (0..oc).map(|o| mul(xn_sq, w.sq[o])).collect();
+    let cmax = *colsq.iter().max().unwrap();
+    let mut resc = vec![0i64; s * oc];
+    for o in 0..oc {
+        let bacc: i64 = match b { Some(bv) => { let cs = colsq[o]; if cs == 0 { 0 } else { (fdiv((bv.v[o] as i128) * bv.sq * (1i128 << SC) + (cs >> 1), cs) >> SC) as i64 } }, None => 0 };
+        let ratio = (colsq[o] << SC) / cmax;
+        for si in 0..s { resc[si * oc + o] = apply((acc[si * oc + o] + bacc) as i128, ratio) as i64; }
+    }
+    aq(&resc, cmax)
+}
+fn rope(x: &mut [i64], s: usize, nh: usize, cosq: &[i64], sinq: &[i64]) {
+    let src = x.to_vec();
+    for si in 0..s { for h in 0..nh { for d in 0..HD {
+        let base = (si * nh + h) * HD;
+        let rh = if d < HD / 2 { -src[base + d + HD / 2] } else { src[base + d - HD / 2] };
+        x[base + d] = (src[base + d] * cosq[si * HD + d] + rh * sinq[si * HD + d] + 16384) >> 15;
+    } } }
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let path = args.get(1).cloned().unwrap_or("model.bin".into());
+    let ndecode: usize = args.get(2).and_then(|x| x.parse().ok()).unwrap_or(6);
+    let mut buf = Vec::new(); std::fs::File::open(&path).unwrap().read_to_end(&mut buf).unwrap();
+    assert_eq!(&buf[0..8], b"QCM0\0\0\0\0");
+    let mut c = Cur { b: &buf, p: 8 };
+    let nl = c.u32() as usize; let smax = c.u32() as usize;
+    assert_eq!(nl, NL);
+    let emb = rd_w2d(&mut c);
+    assert_eq!(emb.rows, VOCAB); assert_eq!(emb.cols, D);
+    let layers: Vec<Layer> = (0..NL).map(|_| Layer {
+        ln1: rd_v1d(&mut c), qw: rd_w2d(&mut c), qb: rd_v1d(&mut c), kw: rd_w2d(&mut c), kb: rd_v1d(&mut c),
+        vw: rd_w2d(&mut c), vb: rd_v1d(&mut c), ow: rd_w2d(&mut c), ln2: rd_v1d(&mut c),
+        gw: rd_w2d(&mut c), uw: rd_w2d(&mut c), dw: rd_w2d(&mut c),
+    }).collect();
+    let fnorm = rd_v1d(&mut c);
+    let cosq: Vec<i64> = (0..smax * HD).map(|_| c.i64()).collect();
+    let sinq: Vec<i64> = (0..smax * HD).map(|_| c.i64()).collect();
+    let exp: Vec<i64> = (0..2048).map(|_| c.i64()).collect();
+    let sig: Vec<i64> = (0..16384).map(|_| c.i64()).collect();
+
+    let forward = |tokens: &[usize]| -> usize {
+        let s = tokens.len();
+        let mut hv = vec![0i64; s * D];
+        let mut xsq = vec![0i128; s];
+        for (si, &t) in tokens.iter().enumerate() {
+            for d in 0..D { hv[si * D + d] = emb.w[t * D + d] as i64; }
+            xsq[si] = emb.sq[t];
+        }
+        for l in &layers {
+            let (xn_q, xn_sq) = rmsnorm(&hv, s, &l.ln1);
+            let (mut qq, qsq) = proj(&l.qw, Some(&l.qb), s, &xn_q, xn_sq);
+            let (mut kq, ksq) = proj(&l.kw, Some(&l.kb), s, &xn_q, xn_sq);
+            let (vq, vsq) = proj(&l.vw, Some(&l.vb), s, &xn_q, xn_sq);
+            rope(&mut qq, s, NH, &cosq, &sinq);
+            rope(&mut kq, s, NKV, &cosq, &sinq);
+            let g = NH / NKV;
+            let c512 = mul(qsq, ksq) * 64;
+            let mut attn = vec![0i64; s * D];
+            for h in 0..NH { let kvh = h / g; for si in 0..s {
+                let mut scores = vec![0i64; si + 1];
+                for t in 0..=si { let mut a = 0i64; for d in 0..HD { a += qq[(si * NH + h) * HD + d] * kq[(t * NKV + kvh) * HD + d]; } scores[t] = a; }
+                let m = *scores.iter().max().unwrap();
+                let mut e = vec![0i64; si + 1]; let mut den: i128 = 0;
+                for t in 0..=si { let mut dd = apply((m - scores[t]) as i128, c512); if dd < 0 { dd = 0; } if dd > 2047 { dd = 2047; } e[t] = exp[dd as usize]; den += e[t] as i128; }
+                for d in 0..HD {
+                    let mut acc: i128 = 0; for t in 0..=si { acc += (e[t] as i128) * (vq[(t * NKV + kvh) * HD + d] as i128); }
+                    attn[si * D + h * HD + d] = (fdiv(acc * (1i128 << SC) + (den >> 1), den) >> SC) as i64;
+                }
+            } }
+            let (aqa, aqa_sq) = aq(&attn, vsq);
+            let mut hout = vec![0i64; s * D];
+            for si in 0..s { for d2 in 0..D {
+                let mut a = 0i64; for d in 0..D { a += aqa[si * D + d] * (l.ow.w[d2 * D + d] as i64); }
+                let ocsq = mul(aqa_sq, l.ow.sq[d2]);
+                hout[si * D + d2] = hv[si * D + d2] + apply(a as i128, (ocsq << SC) / xsq[si]) as i64;
+            } }
+            // MLP
+            let (xn2_q, xn2_sq) = rmsnorm(&hout, s, &l.ln2);
+            let (gate_q, gate_sq) = proj(&l.gw, None, s, &xn2_q, xn2_sq);
+            let (up_q, _up_used) = proj(&l.uw, None, s, &xn2_q, xn2_sq);
+            let up_sq = _up_used;
+            let gs9 = gate_sq << 9;
+            let mut act_int = vec![0i64; s * FF];
+            for i in 0..s * FF {
+                let mut idx = ((gate_q[i] as i128 * gs9 + HALF) >> SC) + 8192;
+                if idx < 0 { idx = 0; } if idx > 16383 { idx = 16383; }
+                act_int[i] = gate_q[i] * sig[idx as usize];
+            }
+            let (act_q, spre) = aq(&act_int, gate_sq); let act_sq = spre >> 16;
+            let mut hmul = vec![0i64; s * FF];
+            for i in 0..s * FF { hmul[i] = act_q[i] * up_q[i]; }
+            let (hmul_q, hmul_q_sq) = aq(&hmul, mul(act_sq, up_sq));
+            let (mlp_q, mlp_sq) = proj(&l.dw, None, s, &hmul_q, hmul_q_sq);
+            for si in 0..s { let ratio = (mlp_sq << SC) / xsq[si]; for d2 in 0..D { hv[si * D + d2] = hout[si * D + d2] + apply(mlp_q[si * D + d2] as i128, ratio) as i64; } }
+        }
+        let (xn_q, _) = rmsnorm(&hv, s, &fnorm);
+        // tied LM head: score[v] = (raw[v] * emb_scale[v] + HALF) >> SC, integer argmax (first max)
+        let last = &xn_q[(s - 1) * D..s * D];
+        let mut best_v = 0usize; let mut best: i128 = i128::MIN;
+        for v in 0..VOCAB {
+            let mut raw = 0i64; let base = v * D;
+            for d in 0..D { raw += last[d] * (emb.w[base + d] as i64); }
+            let sc = (raw as i128 * emb.sq[v] + HALF) >> SC;
+            if sc > best { best = sc; best_v = v; }
+        }
+        best_v
+    };
+
+    let prompt = [9707usize, 11, 1879, 30];
+    let mut toks: Vec<usize> = prompt.to_vec();
+    let mut gen: Vec<usize> = Vec::new();
+    for _ in 0..ndecode { let nt = forward(&toks); gen.push(nt); toks.push(nt); }
+    let bytes: Vec<u8> = gen.iter().flat_map(|&t| (t as i64).to_le_bytes()).collect();
+    println!("backend   = Rust CPU ({})", std::env::consts::ARCH);
+    println!("generated = {:?}", gen);
+    println!("ids FNV   = {:016x}", fnv(&bytes));
+    println!("EXPECTED  = [3555, 374, 279, 7290, 315, 279] (Python reference, 6/6 vs fp)");
+}
diff --git a/docs/evidence/canon_model_hifi.py b/docs/evidence/canon_model_hifi.py
new file mode 100644
index 0000000000000000000000000000000000000000..713d9828c0853d59189809f1872e815126af476a
--- /dev/null
+++ b/docs/evidence/canon_model_hifi.py
@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+# inc4b-4 reference: FULLY-INTEGER full Qwen2.5-0.5B forward = 24 layers + final RMSNorm + tied LM head +
+# integer argmax, with greedy decode. No fp on the compute path. Produces a backend-independent TOKEN
+# commitment (blake2b over the greedy token ids) and checks token-agreement vs the fp reference.
+import sys, json, struct, hashlib, numpy as np
+CANON = sys.argv[1] if len(sys.argv) > 1 else "/root/models/qwen05.canon"
+NDECODE = int(sys.argv[2]) if len(sys.argv) > 2 else 8
+D, NH, NKV, HD, THETA, FF, NL = 896, 14, 2, 64, 1000000.0, 4864, 24
+VOCAB = 151936; SC = 60; HALF = 1 << (SC-1); ALVL = (1 << 23) - 1  # A24 activations, Q60 scales
+
+def qmf(m0, sh): e = sh - 31 + SC; return (m0 << e) if e >= 0 else ((m0 + (1 << (-e-1))) >> (-e))
+def apply(a, s): return (a*s + HALF) >> SC
+def mul(a, b): return (a*b + HALF) >> SC
+def sfrom(amax, cur): return (amax*cur)//ALVL
+def isqrt(n):
+    if n <= 0: return 0
+    x = int(n); y = (x+1)//2
+    while y < x: x = y; y = (x + int(n)//x)//2
+    return x
+def aq(v, cur):
+    amax = int(np.max(np.abs(v))) or 1
+    vo = v.astype(object)
+    q = ((vo*ALVL*2 + np.sign(vo)*amax)//(2*amax)).astype(np.int64)
+    return q, sfrom(amax, cur)
+def read_canon(path):
+    f = open(path, "rb"); assert f.read(8) == b"CANONv1\n"
+    n = struct.unpack("<Q", f.read(8))[0]; hdr = json.loads(f.read(n)); body = f.read(); out = {}
+    for t in hdr["tensors"]:
+        nm, k, shp = t["name"], t["kind"], t["shape"]
+        if k == "w2d_int8_pcs":
+            o, i = shp
+            w = np.frombuffer(body[t["w_off"]:t["w_off"]+o*i], np.int8).reshape(o, i).astype(np.int64)
+            sc = np.frombuffer(body[t["s_off"]:t["s_off"]+o*8], np.int32).reshape(o, 2)
+            out[nm] = ("w", w, np.array([qmf(int(a), int(b)) for a, b in sc], object))
+        else:
+            v = np.frombuffer(body[t["w_off"]:t["w_off"]+shp[0]*4], np.int32).astype(np.int64)
+            m0, sh = struct.unpack("<ii", body[t["s_off"]:t["s_off"]+8]); out[nm] = ("v", v, qmf(m0, sh))
+    return out
+T = read_canon(CANON)
+def imm(a, w): return a @ w.T
+def build_exp(nt=28):
+    ONE = 1 << 16; t = np.zeros(2048, np.int64)
+    for d in range(2048):
+        x = -d*(ONE//512); e = ONE; k = nt
+        while k >= 1: e = ONE+((x*e)//ONE)//k; k -= 1
+        t[d] = max(0, e)
+    return t
+EXP = build_exp()
+SIG = np.clip(np.rint(1.0/(1.0+np.exp(-(np.arange(16384)-8192)/512.0))*(1 << 16)), 0, 1 << 16).astype(np.int64)
+
+def rms_q(hv, gname, S):
+    gv, gsq = T[gname][1], T[gname][2]
+    ss = np.sum(hv**2, 1); mean = ss//D + 1
+    inv = np.array([isqrt((1 << 40)//int(m)) for m in mean], np.int64)
+    yg = (hv*inv[:, None])*gv[None, :]; q, s0 = aq(yg, 1 << SC)
+    return q, mul(mul(s0, qmf(1, 11)), int(gsq))
+def proj(wname, bname, xn_q, xn_sq, S):
+    _, wv, wsq = T[wname]; acc = imm(xn_q, wv); OUT = acc.shape[1]
+    colsq = [mul(int(xn_sq), int(wsq[o])) for o in range(OUT)]
+    if bname:
+        bv, bsq = T[bname][1], int(T[bname][2])
+        bacc = np.array([(((int(bv[o])*bsq*(1 << SC)+(cs >> 1))//cs) >> SC) if (cs := colsq[o]) else 0 for o in range(OUT)], np.int64)
+    else:
+        bacc = np.zeros(OUT, np.int64)
+    accb = acc + bacc[None, :]; cmax = max(colsq); resc = np.empty_like(acc)
+    for o in range(OUT):  # exact requant (A24 products exceed int64)
+        r = (colsq[o] << SC)//cmax
+        resc[:, o] = np.array([ (int(x)*r + HALF) >> SC for x in accb[:, o] ], dtype=np.int64)
+    q, sq = aq(resc.reshape(-1), cmax); return q.reshape(acc.shape), sq
+
+def rope_tables(S):
+    inv_freq = 1.0/(THETA**(np.arange(0, HD, 2)/HD)); ang = np.outer(np.arange(S), inv_freq)
+    cF = np.concatenate([np.cos(ang)]*2, 1); sF = np.concatenate([np.sin(ang)]*2, 1)
+    return (np.clip(np.rint(cF*32768), -32768, 32767).astype(np.int64),
+            np.clip(np.rint(sF*32768), -32768, 32767).astype(np.int64))
+def rope_int(xq, cosQ, sinQ):
+    rh = np.concatenate([-xq[..., HD//2:], xq[..., :HD//2]], -1)
+    return (xq*cosQ[:, None, :] + rh*sinQ[:, None, :] + 16384) >> 15
+
+def layer(hv, l, Xsq, cosQ, sinQ):
+    S = hv.shape[0]; L = f"model.layers.{l}."
+    xn_q, xn_sq = rms_q(hv, L+"input_layernorm.weight", S)
+    qf, qsq = proj(L+"self_attn.q_proj.weight", L+"self_attn.q_proj.bias", xn_q, xn_sq, S)
+    kf, ksq = proj(L+"self_attn.k_proj.weight", L+"self_attn.k_proj.bias", xn_q, xn_sq, S)
+    vf, vsq = proj(L+"self_attn.v_proj.weight", L+"self_attn.v_proj.bias", xn_q, xn_sq, S)
+    qq = rope_int(qf.reshape(S, NH, HD), cosQ, sinQ); kq = rope_int(kf.reshape(S, NKV, HD), cosQ, sinQ); vq = vf.reshape(S, NKV, HD)
+    kq14 = np.repeat(kq, NH//NKV, 1); vq14 = np.repeat(vq, NH//NKV, 1)
+    scores = np.einsum('shd,thd->hst', qq, kq14); C8 = mul(qsq, ksq)*64  # 1/512 exp units
+    attn = np.zeros((S, D), np.int64)
+    for h in range(NH):
+        for s in range(S):
+            row = scores[h, s, :s+1]; m = int(row.max())
+            d = np.clip([apply(m-int(r), C8) for r in row], 0, 2047); e = EXP[np.array(d)]; den = int(e.sum())
+            accv = e @ vq14[:s+1, h, :]      # [HD] int64 (fits), exact per-lane division below
+            for dd in range(HD):
+                attn[s, h*HD+dd] = ((int(accv[dd])*(1 << SC)+(den >> 1))//den) >> SC
+    aqa, aqa_sq = aq(attn.reshape(-1), vsq); aqa = aqa.reshape(S, D)
+    _, wo, wosq = T[L+"self_attn.o_proj.weight"]; oacc = imm(aqa, wo)
+    ocsq = [mul(int(aqa_sq), int(wosq[dd])) for dd in range(D)]
+    hout = np.zeros((S, D), np.int64)
+    for s in range(S):
+        for dd in range(D): hout[s, dd] = hv[s, dd] + apply(int(oacc[s, dd]), (ocsq[dd] << SC)//Xsq[s])
+    # MLP
+    xn2_q, xn2_sq = rms_q(hout, L+"post_attention_layernorm.weight", S)
+    gate_q, gate_sq = proj(L+"mlp.gate_proj.weight", None, xn2_q, xn2_sq, S)
+    up_q, up_sq = proj(L+"mlp.up_proj.weight", None, xn2_q, xn2_sq, S)
+    gs9 = int(gate_sq) << 9
+    idx = np.clip(np.array([[((int(x)*gs9 + HALF) >> SC) + 8192 for x in row] for row in gate_q], dtype=np.int64), 0, 16383)
+    sig = SIG[idx]
+    act_int = gate_q*sig; act_q, spre = aq(act_int.reshape(-1), int(gate_sq)); act_q = act_q.reshape(S, FF); act_sq = spre >> 16
+    hmul = act_q*up_q; hmul_sq = mul(int(act_sq), int(up_sq))
+    hmul_q, hmul_q_sq = aq(hmul.reshape(-1), hmul_sq); hmul_q = hmul_q.reshape(S, FF)
+    mlp_q, mlp_sq = proj(L+"mlp.down_proj.weight", None, hmul_q, hmul_q_sq, S)
+    out = np.zeros((S, D), np.int64)
+    for s in range(S):
+        r = (int(mlp_sq) << SC)//Xsq[s]
+        for dd in range(D): out[s, dd] = hout[s, dd] + apply(int(mlp_q[s, dd]), r)
+    return out
+
+Wemb, Wemb_sq = T["model.embed_tokens.weight"][1], T["model.embed_tokens.weight"][2]
+def forward_last_logits_argmax(tokens):
+    S = len(tokens)
+    hv = np.stack([Wemb[t] for t in tokens]).astype(np.int64)
+    Xsq = [int(Wemb_sq[t]) for t in tokens]
+    cosQ, sinQ = rope_tables(S)
+    for l in range(NL): hv = layer(hv, l, Xsq, cosQ, sinQ)
+    xn_q, xn_sq = rms_q(hv, "model.norm.weight", S)     # final norm
+    last = xn_q[S-1]                                     # [D] int16
+    raw = last.astype(np.int64) @ Wemb.T.astype(np.int64)   # [VOCAB]  (tied LM head)
+    escale = np.array([int(Wemb_sq[v]) for v in range(VOCAB)], object)
+    score = (raw.astype(object)*escale + HALF) >> SC    # exact: Q60 scale x 2^40 raw exceeds int64
+    return int(np.argmax(score))                        # first-max tie-break (numpy argmax)
+
+# ---- fp reference forward (dequantized weights) for token-agreement (4b-5) ----
+def wd(n): _, w, s = T[n]; return w.astype(np.float64) * np.array([int(s[o])/(1 << SC) for o in range(w.shape[0])])[:, None]
+def vd(n): _, v, s = T[n]; return v.astype(np.float64) * (int(s)/(1 << SC))
+Wemb_fp = Wemb.astype(np.float64) * np.array([int(Wemb_sq[v])/(1 << SC) for v in range(VOCAB)])[:, None]
+def rmsfp(h, g): return h/np.sqrt(np.mean(h*h, 1, keepdims=True)+1e-6)*g
+def fp_argmax(tokens):
+    S = len(tokens); h = Wemb_fp[tokens].copy()
+    invf = 1.0/(THETA**(np.arange(0, HD, 2)/HD)); ang = np.outer(np.arange(S), invf)
+    cF = np.concatenate([np.cos(ang)]*2, 1); sF = np.concatenate([np.sin(ang)]*2, 1)
+    rhf = lambda x: np.concatenate([-x[..., HD//2:], x[..., :HD//2]], -1)
+    for l in range(NL):
+        L = f"model.layers.{l}."
+        x = rmsfp(h, vd(L+"input_layernorm.weight"))
+        q = (x@wd(L+"self_attn.q_proj.weight").T+vd(L+"self_attn.q_proj.bias")).reshape(S, NH, HD)
+        k = (x@wd(L+"self_attn.k_proj.weight").T+vd(L+"self_attn.k_proj.bias")).reshape(S, NKV, HD)
+        v = (x@wd(L+"self_attn.v_proj.weight").T+vd(L+"self_attn.v_proj.bias")).reshape(S, NKV, HD)
+        q = q*cF[:, None, :]+rhf(q)*sF[:, None, :]; k = k*cF[:, None, :]+rhf(k)*sF[:, None, :]
+        k14 = np.repeat(k, NH//NKV, 1); v14 = np.repeat(v, NH//NKV, 1); sc = np.einsum('shd,thd->hst', q, k14)/np.sqrt(HD)
+        for hh in range(NH):
+            for s in range(S): sc[hh, s, s+1:] = -1e30
+        af = np.zeros((S, NH, HD))
+        for hh in range(NH):
+            p = np.exp(sc[hh]-sc[hh].max(1, keepdims=True)); p /= p.sum(1, keepdims=True); af[:, hh, :] = p@v14[:, hh, :]
+        h = h + af.reshape(S, D)@wd(L+"self_attn.o_proj.weight").T
+        x2 = rmsfp(h, vd(L+"post_attention_layernorm.weight"))
+        g = x2@wd(L+"mlp.gate_proj.weight").T; u = x2@wd(L+"mlp.up_proj.weight").T
+        h = h + ((g/(1.0+np.exp(-g)))*u)@wd(L+"mlp.down_proj.weight").T
+    h = rmsfp(h, vd("model.norm.weight"))
+    return int(np.argmax(h[S-1]@Wemb_fp.T))
+
+prompt = [9707, 11, 1879, 30]
+toks = list(prompt); gen = []; toks_fp = list(prompt); gen_fp = []; match = 0
+for _ in range(NDECODE):
+    nt = forward_last_logits_argmax(toks); gen.append(nt); toks.append(nt)
+    nf = fp_argmax(toks_fp); gen_fp.append(nf); toks_fp.append(nf)
+    if nt == nf: match += 1
+commit = hashlib.blake2b(bytes(np.array(gen, np.int64).tobytes()), digest_size=16).hexdigest()
+print(f"prompt={prompt}")
+print(f"integer generated = {gen}")
+print(f"fp      generated = {gen_fp}")
+print(f"token agreement (int vs fp) = {match}/{NDECODE}")
+print(f"TOKEN COMMITMENT (blake2b16) = {commit}   <- backend-independent (integer canonical class)")
diff --git a/docs/evidence/canon_model_int.py b/docs/evidence/canon_model_int.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1ff75ee2db45654a9f5a2f125c5b27e892afd03
--- /dev/null
+++ b/docs/evidence/canon_model_int.py
@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+# inc4b-4 reference: FULLY-INTEGER full Qwen2.5-0.5B forward = 24 layers + final RMSNorm + tied LM head +
+# integer argmax, with greedy decode. No fp on the compute path. Produces a backend-independent TOKEN
+# commitment (blake2b over the greedy token ids) and checks token-agreement vs the fp reference.
+import sys, json, struct, hashlib, numpy as np
+CANON = sys.argv[1] if len(sys.argv) > 1 else "/root/models/qwen05.canon"
+NDECODE = int(sys.argv[2]) if len(sys.argv) > 2 else 8
+D, NH, NKV, HD, THETA, FF, NL = 896, 14, 2, 64, 1000000.0, 4864, 24
+VOCAB = 151936; SC = 30; HALF = 1 << (SC-1); ALVL = 32767
+
+def qmf(m0, sh): e = sh-1; return (m0 << e) if e >= 0 else ((m0 + (1 << (-e-1))) >> (-e))
+def apply(a, s): return (a*s + HALF) >> SC
+def mul(a, b): return (a*b + HALF) >> SC
+def sfrom(amax, cur): return (amax*cur)//ALVL
+def isqrt(n):
+    if n <= 0: return 0
+    x = int(n); y = (x+1)//2
+    while y < x: x = y; y = (x + int(n)//x)//2
+    return x
+def aq(v, cur):
+    amax = int(np.max(np.abs(v))) or 1
+    return ((v*ALVL*2 + np.sign(v)*amax)//(2*amax)).astype(np.int64), sfrom(amax, cur)
+def read_canon(path):
+    f = open(path, "rb"); assert f.read(8) == b"CANONv1\n"
+    n = struct.unpack("<Q", f.read(8))[0]; hdr = json.loads(f.read(n)); body = f.read(); out = {}
+    for t in hdr["tensors"]:
+        nm, k, shp = t["name"], t["kind"], t["shape"]
+        if k == "w2d_int8_pcs":
+            o, i = shp
+            w = np.frombuffer(body[t["w_off"]:t["w_off"]+o*i], np.int8).reshape(o, i).astype(np.int64)
+            sc = np.frombuffer(body[t["s_off"]:t["s_off"]+o*8], np.int32).reshape(o, 2)
+            out[nm] = ("w", w, np.array([qmf(int(a), int(b)) for a, b in sc], object))
+        else:
+            v = np.frombuffer(body[t["w_off"]:t["w_off"]+shp[0]*4], np.int32).astype(np.int64)
+            m0, sh = struct.unpack("<ii", body[t["s_off"]:t["s_off"]+8]); out[nm] = ("v", v, qmf(m0, sh))
+    return out
+T = read_canon(CANON)
+def imm(a, w): return a @ w.T
+def build_exp(nt=28):
+    ONE = 1 << 16; t = np.zeros(256, np.int64)
+    for d in range(256):
+        x = -d*(ONE//64); e = ONE; k = nt
+        while k >= 1: e = ONE+((x*e)//ONE)//k; k -= 1
+        t[d] = max(0, e)
+    return t
+EXP = build_exp()
+SIG = np.clip(np.rint(1.0/(1.0+np.exp(-(np.arange(4096)-2048)/128.0))*(1 << 16)), 0, 1 << 16).astype(np.int64)
+
+def rms_q(hv, gname, S):
+    gv, gsq = T[gname][1], T[gname][2]
+    ss = np.sum(hv**2, 1); mean = ss//D + 1
+    inv = np.array([isqrt((1 << 40)//int(m)) for m in mean], np.int64)
+    yg = (hv*inv[:, None])*gv[None, :]; q, s0 = aq(yg, 1 << SC)
+    return q, mul(mul(s0, qmf(1, 11)), int(gsq))
+def proj(wname, bname, xn_q, xn_sq, S):
+    _, wv, wsq = T[wname]; acc = imm(xn_q, wv); OUT = acc.shape[1]
+    colsq = [mul(int(xn_sq), int(wsq[o])) for o in range(OUT)]
+    if bname:
+        bv, bsq = T[bname][1], int(T[bname][2])
+        bacc = np.array([(((int(bv[o])*bsq*(1 << SC)+(cs >> 1))//cs) >> SC) if (cs := colsq[o]) else 0 for o in range(OUT)], np.int64)
+    else:
+        bacc = np.zeros(OUT, np.int64)
+    accb = acc + bacc[None, :]; cmax = max(colsq); resc = np.empty_like(acc)
+    for o in range(OUT): resc[:, o] = apply(accb[:, o], (colsq[o] << SC)//cmax)
+    q, sq = aq(resc.reshape(-1), cmax); return q.reshape(acc.shape), sq
+
+def rope_tables(S):
+    inv_freq = 1.0/(THETA**(np.arange(0, HD, 2)/HD)); ang = np.outer(np.arange(S), inv_freq)
+    cF = np.concatenate([np.cos(ang)]*2, 1); sF = np.concatenate([np.sin(ang)]*2, 1)
+    return (np.clip(np.rint(cF*32768), -32768, 32767).astype(np.int64),
+            np.clip(np.rint(sF*32768), -32768, 32767).astype(np.int64))
+def rope_int(xq, cosQ, sinQ):
+    rh = np.concatenate([-xq[..., HD//2:], xq[..., :HD//2]], -1)
+    return (xq*cosQ[:, None, :] + rh*sinQ[:, None, :] + 16384) >> 15
+
+def layer(hv, l, Xsq, cosQ, sinQ):
+    S = hv.shape[0]; L = f"model.layers.{l}."
+    xn_q, xn_sq = rms_q(hv, L+"input_layernorm.weight", S)
+    qf, qsq = proj(L+"self_attn.q_proj.weight", L+"self_attn.q_proj.bias", xn_q, xn_sq, S)
+    kf, ksq = proj(L+"self_attn.k_proj.weight", L+"self_attn.k_proj.bias", xn_q, xn_sq, S)
+    vf, vsq = proj(L+"self_attn.v_proj.weight", L+"self_attn.v_proj.bias", xn_q, xn_sq, S)
+    qq = rope_int(qf.reshape(S, NH, HD), cosQ, sinQ); kq = rope_int(kf.reshape(S, NKV, HD), cosQ, sinQ); vq = vf.reshape(S, NKV, HD)
+    kq14 = np.repeat(kq, NH//NKV, 1); vq14 = np.repeat(vq, NH//NKV, 1)
+    scores = np.einsum('shd,thd->hst', qq, kq14); C8 = mul(qsq, ksq)*8
+    attn = np.zeros((S, D), np.int64)
+    for h in range(NH):
+        for s in range(S):
+            row = scores[h, s, :s+1]; m = int(row.max())
+            d = np.clip([apply(m-int(r), C8) for r in row], 0, 255); e = EXP[np.array(d)]; den = int(e.sum())
+            accv = e @ vq14[:s+1, h, :]      # [HD] int64 (fits), exact per-lane division below
+            for dd in range(HD):
+                attn[s, h*HD+dd] = ((int(accv[dd])*(1 << SC)+(den >> 1))//den) >> SC
+    aqa, aqa_sq = aq(attn.reshape(-1), vsq); aqa = aqa.reshape(S, D)
+    _, wo, wosq = T[L+"self_attn.o_proj.weight"]; oacc = imm(aqa, wo)
+    ocsq = [mul(int(aqa_sq), int(wosq[dd])) for dd in range(D)]
+    hout = np.zeros((S, D), np.int64)
+    for s in range(S):
+        for dd in range(D): hout[s, dd] = hv[s, dd] + apply(int(oacc[s, dd]), (ocsq[dd] << SC)//Xsq[s])
+    # MLP
+    xn2_q, xn2_sq = rms_q(hout, L+"post_attention_layernorm.weight", S)
+    gate_q, gate_sq = proj(L+"mlp.gate_proj.weight", None, xn2_q, xn2_sq, S)
+    up_q, up_sq = proj(L+"mlp.up_proj.weight", None, xn2_q, xn2_sq, S)
+    idx = np.clip(apply(gate_q, int(gate_sq) << 7) + 2048, 0, 4095); sig = SIG[idx]
+    act_int = gate_q*sig; act_q, spre = aq(act_int.reshape(-1), int(gate_sq)); act_q = act_q.reshape(S, FF); act_sq = spre >> 16
+    hmul = act_q*up_q; hmul_sq = mul(int(act_sq), int(up_sq))
+    hmul_q, hmul_q_sq = aq(hmul.reshape(-1), hmul_sq); hmul_q = hmul_q.reshape(S, FF)
+    mlp_q, mlp_sq = proj(L+"mlp.down_proj.weight", None, hmul_q, hmul_q_sq, S)
+    out = np.zeros((S, D), np.int64)
+    for s in range(S):
+        r = (int(mlp_sq) << SC)//Xsq[s]
+        for dd in range(D): out[s, dd] = hout[s, dd] + apply(int(mlp_q[s, dd]), r)
+    return out
+
+Wemb, Wemb_sq = T["model.embed_tokens.weight"][1], T["model.embed_tokens.weight"][2]
+def forward_last_logits_argmax(tokens):
+    S = len(tokens)
+    hv = np.stack([Wemb[t] for t in tokens]).astype(np.int64)
+    Xsq = [int(Wemb_sq[t]) for t in tokens]
+    cosQ, sinQ = rope_tables(S)
+    for l in range(NL): hv = layer(hv, l, Xsq, cosQ, sinQ)
+    xn_q, xn_sq = rms_q(hv, "model.norm.weight", S)     # final norm
+    last = xn_q[S-1]                                     # [D] int16
+    raw = last.astype(np.int64) @ Wemb.T.astype(np.int64)   # [VOCAB]  (tied LM head)
+    escale = np.array([int(Wemb_sq[v]) for v in range(VOCAB)], np.int64)
+    score = (raw*escale + HALF) >> SC                   # weight each vocab by its scale, argmax-equivalent
+    return int(np.argmax(score))                        # first-max tie-break (numpy argmax)
+
+# ---- fp reference forward (dequantized weights) for token-agreement (4b-5) ----
+def wd(n): _, w, s = T[n]; return w.astype(np.float64) * np.array([int(s[o])/(1 << SC) for o in range(w.shape[0])])[:, None]
+def vd(n): _, v, s = T[n]; return v.astype(np.float64) * (int(s)/(1 << SC))
+Wemb_fp = Wemb.astype(np.float64) * np.array([int(Wemb_sq[v])/(1 << SC) for v in range(VOCAB)])[:, None]
+def rmsfp(h, g): return h/np.sqrt(np.mean(h*h, 1, keepdims=True)+1e-6)*g
+def fp_argmax(tokens):
+    S = len(tokens); h = Wemb_fp[tokens].copy()
+    invf = 1.0/(THETA**(np.arange(0, HD, 2)/HD)); ang = np.outer(np.arange(S), invf)
+    cF = np.concatenate([np.cos(ang)]*2, 1); sF = np.concatenate([np.sin(ang)]*2, 1)
+    rhf = lambda x: np.concatenate([-x[..., HD//2:], x[..., :HD//2]], -1)
+    for l in range(NL):
+        L = f"model.layers.{l}."
+        x = rmsfp(h, vd(L+"input_layernorm.weight"))
+        q = (x@wd(L+"self_attn.q_proj.weight").T+vd(L+"self_attn.q_proj.bias")).reshape(S, NH, HD)
+        k = (x@wd(L+"self_attn.k_proj.weight").T+vd(L+"self_attn.k_proj.bias")).reshape(S, NKV, HD)
+        v = (x@wd(L+"self_attn.v_proj.weight").T+vd(L+"self_attn.v_proj.bias")).reshape(S, NKV, HD)
+        q = q*cF[:, None, :]+rhf(q)*sF[:, None, :]; k = k*cF[:, None, :]+rhf(k)*sF[:, None, :]
+        k14 = np.repeat(k, NH//NKV, 1); v14 = np.repeat(v, NH//NKV, 1); sc = np.einsum('shd,thd->hst', q, k14)/np.sqrt(HD)
+        for hh in range(NH):
+            for s in range(S): sc[hh, s, s+1:] = -1e30
+        af = np.zeros((S, NH, HD))
+        for hh in range(NH):
+            p = np.exp(sc[hh]-sc[hh].max(1, keepdims=True)); p /= p.sum(1, keepdims=True); af[:, hh, :] = p@v14[:, hh, :]
+        h = h + af.reshape(S, D)@wd(L+"self_attn.o_proj.weight").T
+        x2 = rmsfp(h, vd(L+"post_attention_layernorm.weight"))
+        g = x2@wd(L+"mlp.gate_proj.weight").T; u = x2@wd(L+"mlp.up_proj.weight").T
+        h = h + ((g/(1.0+np.exp(-g)))*u)@wd(L+"mlp.down_proj.weight").T
+    h = rmsfp(h, vd("model.norm.weight"))
+    return int(np.argmax(h[S-1]@Wemb_fp.T))
+
+prompt = [9707, 11, 1879, 30]
+toks = list(prompt); gen = []; toks_fp = list(prompt); gen_fp = []; match = 0
+for _ in range(NDECODE):
+    nt = forward_last_logits_argmax(toks); gen.append(nt); toks.append(nt)
+    nf = fp_argmax(toks_fp); gen_fp.append(nf); toks_fp.append(nf)
+    if nt == nf: match += 1
+commit = hashlib.blake2b(bytes(np.array(gen, np.int64).tobytes()), digest_size=16).hexdigest()
+print(f"prompt={prompt}")
+print(f"integer generated = {gen}")
+print(f"fp      generated = {gen_fp}")
+print(f"token agreement (int vs fp) = {match}/{NDECODE}")
+print(f"TOKEN COMMITMENT (blake2b16) = {commit}   <- backend-independent (integer canonical class)")
diff --git a/docs/evidence/canon_ops.rs b/docs/evidence/canon_ops.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7651a1b9cabbc72982aaca531f26815e885e1a4a
--- /dev/null
+++ b/docs/evidence/canon_ops.rs
@@ -0,0 +1,97 @@
+// Canonical integer OPS (increment 4a): softmax (fixed-point exp) + RMSNorm (integer rsqrt) + argmax.
+// The remaining transcendental-bearing transformer ops, all integer, NO floating point. CPU reference.
+// Build/run:  rustc -O canon_ops.rs -o canon_ops && ./canon_ops
+
+fn splitmix64(s: &mut u64) -> u64 {
+    *s = s.wrapping_add(0x9E3779B97F4A7C15);
+    let mut z = *s;
+    z = (z ^ (z >> 30)).wrapping_mul(0xBF58476D1CE4E5B9);
+    z = (z ^ (z >> 27)).wrapping_mul(0x94D049BB133111EB);
+    z ^ (z >> 31)
+}
+fn fnv(bytes: &[u8]) -> u64 {
+    let mut h: u64 = 0xcbf29ce484222325;
+    for &b in bytes { h ^= b as u64; h = h.wrapping_mul(0x100000001b3); }
+    h
+}
+
+// --- fixed-point exp table: exp(-d/64) in Q16, integer Horner (12 terms). Deterministic, no fp. ---
+const ONE_Q16: i64 = 1 << 16;
+fn exp_neg_q16(d: i32) -> u32 {
+    // arg = -d/64 in Q16
+    let x: i64 = -(d as i64) * (ONE_Q16 / 64); // = -d*1024
+    let mut e: i64 = ONE_Q16;
+    let mut k: i64 = 12;
+    while k >= 1 {
+        // e = 1 + (x/k)*e  (Q16):  (x*e)>>16 gives Q16 of x*e, then /k
+        e = ONE_Q16 + ((x * e) / ONE_Q16) / k;
+        k -= 1;
+    }
+    if e < 0 { 0 } else { e as u32 }
+}
+fn build_exp_lut() -> [u32; 256] {
+    let mut t = [0u32; 256];
+    for d in 0..256 { t[d] = exp_neg_q16(d as i32); }
+    t
+}
+
+// --- integer isqrt (floor) via Newton; deterministic. ---
+fn isqrt(n: u64) -> u64 {
+    if n == 0 { return 0; }
+    let mut x = n;
+    let mut y = (x + 1) / 2;
+    while y < x { x = y; y = (x + n / x) / 2; }
+    x
+}
+
+fn main() {
+    // ---------- softmax over L int32 scores ----------
+    let l = 1024usize;
+    let mut ss = 0x71u64;
+    let scores: Vec<i32> = (0..l).map(|_| (splitmix64(&mut ss) % 20000) as i32 - 10000).collect();
+    let exp_lut = build_exp_lut();
+    const DSCALE: i32 = 78; // maps score gap -> exp table index d in [0,255]
+    let m = *scores.iter().max().unwrap();
+    let mut e: Vec<u32> = Vec::with_capacity(l);
+    let mut sum: u64 = 0;
+    for &s in &scores {
+        let mut d = (m - s) / DSCALE;
+        if d < 0 { d = 0; } if d > 255 { d = 255; }
+        let ev = exp_lut[d as usize];
+        e.push(ev);
+        sum += ev as u64;
+    }
+    // probabilities in Q16: p_i = (e_i << 16) / sum   (integer division, deterministic)
+    let probs: Vec<u32> = e.iter().map(|&ev| (((ev as u64) << 16) / sum) as u32).collect();
+    let softmax_h = fnv(&probs.iter().flat_map(|x| x.to_le_bytes()).collect::<Vec<u8>>());
+    let exp_lut_h = fnv(&exp_lut.iter().flat_map(|x| x.to_le_bytes()).collect::<Vec<u8>>());
+
+    // ---------- RMSNorm over H int32, integer rsqrt ----------
+    let h = 896usize;
+    let mut sx = 0x72u64;
+    let x: Vec<i32> = (0..h).map(|_| (splitmix64(&mut sx) % 2001) as i32 - 1000).collect();
+    let mut sg = 0x73u64;
+    let gamma: Vec<i32> = (0..h).map(|_| 128 + (splitmix64(&mut sg) % 256) as i32).collect(); // ~Q8 gains
+    let ss2: i64 = x.iter().map(|&v| (v as i64) * (v as i64)).sum();
+    let mean: u64 = (ss2 as u64) / (h as u64) + 1; // +eps
+    let inv_q16: u64 = isqrt((1u64 << 32) / mean); // ~ 2^16 / sqrt(mean)
+    let y: Vec<i32> = x.iter().zip(&gamma).map(|(&v, &g)| {
+        let norm = ((v as i64) * (inv_q16 as i64)) >> 16; // x / rms  (approx, scaled)
+        let sc = (norm * (g as i64)) >> 8;                // apply gamma (Q8)
+        sc.clamp(-32768, 32767) as i32
+    }).collect();
+    let rms_h = fnv(&y.iter().flat_map(|v| v.to_le_bytes()).collect::<Vec<u8>>());
+
+    // ---------- argmax (deterministic: first max) ----------
+    let mut ai = 0usize; let mut av = scores[0];
+    for (i, &s) in scores.iter().enumerate() { if s > av { av = s; ai = i; } }
+
+    let combined = fnv(&[softmax_h.to_le_bytes(), rms_h.to_le_bytes(), (ai as u64).to_le_bytes()].concat());
+
+    println!("backend             = CPU ({})", std::env::consts::ARCH);
+    println!("EXP_LUT fnv         = {:016x}", exp_lut_h);
+    println!("softmax fnv         = {:016x}  (probs[0..3]={:?})", softmax_h, &probs[0..3]);
+    println!("rmsnorm fnv         = {:016x}  (inv_q16={}, y[0..3]={:?})", rms_h, inv_q16, &y[0..3]);
+    println!("argmax index        = {}", ai);
+    println!("COMBINED fnv        = {:016x}   <-- GPU builds must reproduce this", combined);
+}
diff --git a/docs/evidence/canon_ops_cuda.cu b/docs/evidence/canon_ops_cuda.cu
new file mode 100644
index 0000000000000000000000000000000000000000..c2023ee852ea8a8e5f14732f91374d6ca24ab098
--- /dev/null
+++ b/docs/evidence/canon_ops_cuda.cu
@@ -0,0 +1,93 @@
+// Canonical integer OPS on NVIDIA CUDA GPU (increment 4a): softmax + RMSNorm on device.
+// Must reproduce CPU: COMBINED 4bf581ead4d57139 (EXP_LUT c4ddbbc186fe4e82).
+// Build/run:  nvcc -O3 -arch=sm_89 canon_ops_cuda.cu -o canon_ops_cuda && ./canon_ops_cuda
+
+#include <cstdio>
+#include <cstdint>
+#include <vector>
+#include <cuda_runtime.h>
+
+static inline uint64_t splitmix64(uint64_t &s) {
+    s += 0x9E3779B97F4A7C15ULL;
+    uint64_t z = s;
+    z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9ULL;
+    z = (z ^ (z >> 27)) * 0x94D049BB133111EBULL;
+    return z ^ (z >> 31);
+}
+static uint64_t fnv(const uint8_t *p, size_t n) {
+    uint64_t h = 0xcbf29ce484222325ULL;
+    for (size_t i = 0; i < n; i++) { h ^= (uint64_t)p[i]; h *= 0x100000001b3ULL; }
+    return h;
+}
+static uint32_t exp_neg_q16(int32_t d) {
+    const int64_t ONE = 1 << 16;
+    int64_t x = -(int64_t)d * (ONE / 64);
+    int64_t e = ONE;
+    for (int64_t k = 12; k >= 1; k--) e = ONE + ((x * e) / ONE) / k;
+    return e < 0 ? 0u : (uint32_t)e;
+}
+static void put_le32(std::vector<uint8_t> &b, uint32_t v) { b.push_back(v & 0xff); b.push_back((v >> 8) & 0xff); b.push_back((v >> 16) & 0xff); b.push_back((v >> 24) & 0xff); }
+static void put_le64(std::vector<uint8_t> &b, uint64_t v) { for (int i = 0; i < 8; i++) b.push_back((v >> (8 * i)) & 0xff); }
+
+__global__ void softmax(const int *scores, const unsigned *elut, unsigned *probs, unsigned L, int DS) {
+    if (blockIdx.x * blockDim.x + threadIdx.x != 0) return;
+    int m = scores[0];
+    for (unsigned i = 1; i < L; i++) if (scores[i] > m) m = scores[i];
+    unsigned long long sum = 0;
+    for (unsigned i = 0; i < L; i++) { int d = (m - scores[i]) / DS; if (d < 0) d = 0; if (d > 255) d = 255; unsigned ev = elut[d]; probs[i] = ev; sum += ev; }
+    for (unsigned i = 0; i < L; i++) probs[i] = (unsigned)(((unsigned long long)probs[i] << 16) / sum);
+}
+__global__ void rmsnorm(const int *x, const int *g, int *y, unsigned H) {
+    if (blockIdx.x * blockDim.x + threadIdx.x != 0) return;
+    long long ssq = 0; for (unsigned i = 0; i < H; i++) { long long v = x[i]; ssq += v * v; }
+    unsigned long long mean = (unsigned long long)ssq / (unsigned long long)H + 1;
+    unsigned long long n = ((unsigned long long)1 << 32) / mean;
+    unsigned long long s = n; if (n > 0) { unsigned long long yy = (s + 1) / 2; while (yy < s) { s = yy; yy = (s + n / s) / 2; } } else s = 0;
+    for (unsigned i = 0; i < H; i++) { long long norm = ((long long)x[i] * (long long)s) >> 16; long long sc = (norm * (long long)g[i]) >> 8; if (sc < -32768) sc = -32768; if (sc > 32767) sc = 32767; y[i] = (int)sc; }
+}
+
+int main() {
+    const unsigned L = 1024, H = 896; const int DSCALE = 78;
+    uint64_t ss = 0x71; std::vector<int> scores(L);
+    for (unsigned i = 0; i < L; i++) scores[i] = (int)(splitmix64(ss) % 20000) - 10000;
+    uint64_t sx = 0x72; std::vector<int> x(H);
+    for (unsigned i = 0; i < H; i++) x[i] = (int)(splitmix64(sx) % 2001) - 1000;
+    uint64_t sg = 0x73; std::vector<int> gamma(H);
+    for (unsigned i = 0; i < H; i++) gamma[i] = 128 + (int)(splitmix64(sg) % 256);
+    std::vector<unsigned> elut(256);
+    for (int d = 0; d < 256; d++) elut[d] = exp_neg_q16(d);
+    std::vector<unsigned> probs(L); std::vector<int> y(H);
+
+    int *dS, *dX, *dG, *dY; unsigned *dE, *dP;
+    cudaMalloc(&dS, L * 4); cudaMalloc(&dE, 256 * 4); cudaMalloc(&dP, L * 4);
+    cudaMalloc(&dX, H * 4); cudaMalloc(&dG, H * 4); cudaMalloc(&dY, H * 4);
+    cudaMemcpy(dS, scores.data(), L * 4, cudaMemcpyHostToDevice);
+    cudaMemcpy(dE, elut.data(), 256 * 4, cudaMemcpyHostToDevice);
+    cudaMemcpy(dX, x.data(), H * 4, cudaMemcpyHostToDevice);
+    cudaMemcpy(dG, gamma.data(), H * 4, cudaMemcpyHostToDevice);
+    softmax<<<1, 1>>>(dS, dE, dP, L, DSCALE);
+    rmsnorm<<<1, 1>>>(dX, dG, dY, H);
+    cudaError_t err = cudaDeviceSynchronize();
+    if (err != cudaSuccess) { printf("cuda error: %s\n", cudaGetErrorString(err)); return 1; }
+    cudaMemcpy(probs.data(), dP, L * 4, cudaMemcpyDeviceToHost);
+    cudaMemcpy(y.data(), dY, H * 4, cudaMemcpyDeviceToHost);
+
+    std::vector<uint8_t> pb; for (unsigned v : probs) put_le32(pb, v);
+    uint64_t softmaxH = fnv(pb.data(), pb.size());
+    std::vector<uint8_t> yb; for (int v : y) put_le32(yb, (uint32_t)v);
+    uint64_t rmsH = fnv(yb.data(), yb.size());
+    int ai = 0, av = scores[0]; for (unsigned i = 0; i < L; i++) if (scores[i] > av) { av = scores[i]; ai = (int)i; }
+    std::vector<uint8_t> eb; for (unsigned v : elut) put_le32(eb, v);
+    uint64_t expLutH = fnv(eb.data(), eb.size());
+    std::vector<uint8_t> cb; put_le64(cb, softmaxH); put_le64(cb, rmsH); put_le64(cb, (uint64_t)ai);
+    uint64_t combined = fnv(cb.data(), cb.size());
+    cudaDeviceProp prop; cudaGetDeviceProperties(&prop, 0);
+    printf("backend             = NVIDIA CUDA GPU (%s, sm_%d%d)\n", prop.name, prop.major, prop.minor);
+    printf("EXP_LUT fnv         = %016llx  (target c4ddbbc186fe4e82)\n", (unsigned long long)expLutH);
+    printf("softmax fnv         = %016llx\n", (unsigned long long)softmaxH);
+    printf("rmsnorm fnv         = %016llx\n", (unsigned long long)rmsH);
+    printf("argmax index        = %d\n", ai);
+    printf("COMBINED fnv        = %016llx  (target 4bf581ead4d57139)\n", (unsigned long long)combined);
+    printf("MATCH               = %s\n", combined == 0x4bf581ead4d57139ULL ? "OK byte-identical" : "MISMATCH");
+    return 0;
+}
diff --git a/docs/evidence/canon_ops_metal.swift b/docs/evidence/canon_ops_metal.swift
new file mode 100644
index 0000000000000000000000000000000000000000..6595bff9b2a64abf2ef3f65e38b00221dc5bf980
--- /dev/null
+++ b/docs/evidence/canon_ops_metal.swift
@@ -0,0 +1,110 @@
+// Canonical integer OPS on Apple Metal GPU (increment 4a): softmax + RMSNorm on device.
+// Must reproduce CPU: COMBINED 4bf581ead4d57139 (EXP_LUT c4ddbbc186fe4e82).
+// Build/run:  swiftc -O canon_ops_metal.swift -o canon_ops_metal && ./canon_ops_metal
+
+import Foundation
+import Metal
+
+func splitmix64(_ s: inout UInt64) -> UInt64 {
+    s = s &+ 0x9E3779B97F4A7C15
+    var z = s
+    z = (z ^ (z >> 30)) &* 0xBF58476D1CE4E5B9
+    z = (z ^ (z >> 27)) &* 0x94D049BB133111EB
+    return z ^ (z >> 31)
+}
+func fnv(_ bytes: [UInt8]) -> UInt64 {
+    var h: UInt64 = 0xcbf29ce484222325
+    for b in bytes { h ^= UInt64(b); h = h &* 0x100000001b3 }
+    return h
+}
+func expNegQ16(_ d: Int32) -> UInt32 {
+    let ONE: Int64 = 1 << 16
+    let x: Int64 = -Int64(d) * (ONE / 64)
+    var e: Int64 = ONE
+    var k: Int64 = 12
+    while k >= 1 { e = ONE + ((x &* e) / ONE) / k; k -= 1 }
+    return e < 0 ? 0 : UInt32(truncatingIfNeeded: e)
+}
+func le32u(_ v: UInt32) -> [UInt8] { [UInt8(v & 0xff), UInt8((v >> 8) & 0xff), UInt8((v >> 16) & 0xff), UInt8((v >> 24) & 0xff)] }
+func le32i(_ v: Int32) -> [UInt8] { le32u(UInt32(bitPattern: v)) }
+func le64(_ v: UInt64) -> [UInt8] { (0..<8).map { UInt8((v >> (8 * $0)) & 0xff) } }
+
+let L = 1024, H = 896, DSCALE: UInt32 = 78
+var ss: UInt64 = 0x71
+let scores: [Int32] = (0..<L).map { _ in Int32(truncatingIfNeeded: splitmix64(&ss) % 20000) - 10000 }
+var sx: UInt64 = 0x72
+let x: [Int32] = (0..<H).map { _ in Int32(truncatingIfNeeded: splitmix64(&sx) % 2001) - 1000 }
+var sg: UInt64 = 0x73
+let gamma: [Int32] = (0..<H).map { _ in Int32(128) + Int32(truncatingIfNeeded: splitmix64(&sg) % 256) }
+var expLut = [UInt32](repeating: 0, count: 256)
+for d in 0..<256 { expLut[d] = expNegQ16(Int32(d)) }
+
+let shader = """
+#include <metal_stdlib>
+using namespace metal;
+kernel void softmax(device const int* scores [[buffer(0)]], device const uint* elut [[buffer(1)]],
+                    device uint* probs [[buffer(2)]], constant uint2& p [[buffer(3)]], uint gid [[thread_position_in_grid]]) {
+    if (gid != 0) return;
+    uint Lv = p.x; int DS = int(p.y);
+    int m = scores[0];
+    for (uint i = 1; i < Lv; i++) if (scores[i] > m) m = scores[i];
+    ulong sum = 0;
+    for (uint i = 0; i < Lv; i++) { int d = (m - scores[i]) / DS; if (d < 0) d = 0; if (d > 255) d = 255; uint ev = elut[d]; probs[i] = ev; sum += ev; }
+    for (uint i = 0; i < Lv; i++) probs[i] = (uint)(((ulong)probs[i] << 16) / sum);
+}
+kernel void rmsnorm(device const int* x [[buffer(0)]], device const int* g [[buffer(1)]],
+                    device int* y [[buffer(2)]], constant uint2& p [[buffer(3)]], uint gid [[thread_position_in_grid]]) {
+    if (gid != 0) return;
+    uint Hv = p.x;
+    long ssq = 0; for (uint i = 0; i < Hv; i++) { long v = x[i]; ssq += v * v; }
+    ulong mean = (ulong)ssq / (ulong)Hv + 1;
+    ulong n = ((ulong)1 << 32) / mean;
+    ulong s = n; if (n > 0) { ulong yy = (s + 1) / 2; while (yy < s) { s = yy; yy = (s + n / s) / 2; } } else s = 0;
+    for (uint i = 0; i < Hv; i++) { long norm = ((long)x[i] * (long)s) >> 16; long sc = (norm * (long)g[i]) >> 8; if (sc < -32768) sc = -32768; if (sc > 32767) sc = 32767; y[i] = (int)sc; }
+}
+"""
+
+guard let dev = MTLCreateSystemDefaultDevice() else { fatalError("no Metal") }
+let lib = try! dev.makeLibrary(source: shader, options: nil)
+let pSoft = try! dev.makeComputePipelineState(function: lib.makeFunction(name: "softmax")!)
+let pRms = try! dev.makeComputePipelineState(function: lib.makeFunction(name: "rmsnorm")!)
+let q = dev.makeCommandQueue()!
+func buf<T>(_ a: [T]) -> MTLBuffer { dev.makeBuffer(bytes: a, length: MemoryLayout<T>.stride * a.count, options: .storageModeShared)! }
+
+let bScores = buf(scores), bElut = buf(expLut), bProbs = dev.makeBuffer(length: L * 4, options: .storageModeShared)!
+var pSoftDims = SIMD2<UInt32>(UInt32(L), DSCALE)
+let bSD = dev.makeBuffer(bytes: &pSoftDims, length: 8, options: .storageModeShared)!
+let bX = buf(x), bG = buf(gamma), bY = dev.makeBuffer(length: H * 4, options: .storageModeShared)!
+var pRmsDims = SIMD2<UInt32>(UInt32(H), 0)
+let bRD = dev.makeBuffer(bytes: &pRmsDims, length: 8, options: .storageModeShared)!
+
+let cmd = q.makeCommandBuffer()!
+let e1 = cmd.makeComputeCommandEncoder()!
+e1.setComputePipelineState(pSoft)
+for (i, b) in [bScores, bElut, bProbs, bSD].enumerated() { e1.setBuffer(b, offset: 0, index: i) }
+e1.dispatchThreads(MTLSize(width: 1, height: 1, depth: 1), threadsPerThreadgroup: MTLSize(width: 1, height: 1, depth: 1))
+e1.endEncoding()
+let e2 = cmd.makeComputeCommandEncoder()!
+e2.setComputePipelineState(pRms)
+for (i, b) in [bX, bG, bY, bRD].enumerated() { e2.setBuffer(b, offset: 0, index: i) }
+e2.dispatchThreads(MTLSize(width: 1, height: 1, depth: 1), threadsPerThreadgroup: MTLSize(width: 1, height: 1, depth: 1))
+e2.endEncoding()
+cmd.commit(); cmd.waitUntilCompleted()
+
+let pptr = bProbs.contents().bindMemory(to: UInt32.self, capacity: L)
+var pbytes = [UInt8](); for i in 0..<L { pbytes += le32u(pptr[i]) }
+let softmaxH = fnv(pbytes)
+let yptr = bY.contents().bindMemory(to: Int32.self, capacity: H)
+var ybytes = [UInt8](); for i in 0..<H { ybytes += le32i(yptr[i]) }
+let rmsH = fnv(ybytes)
+var ai = 0; var av = scores[0]
+for i in 0..<L { if scores[i] > av { av = scores[i]; ai = i } }
+let expLutH = fnv(expLut.flatMap { le32u($0) })
+let combined = fnv(le64(softmaxH) + le64(rmsH) + le64(UInt64(ai)))
+print("backend             = Apple Metal GPU (\(dev.name))")
+print(String(format: "EXP_LUT fnv         = %016llx  (target c4ddbbc186fe4e82)", expLutH))
+print(String(format: "softmax fnv         = %016llx", softmaxH))
+print(String(format: "rmsnorm fnv         = %016llx", rmsH))
+print("argmax index        = \(ai)")
+print(String(format: "COMBINED fnv        = %016llx  (target 4bf581ead4d57139)", combined))
+print("MATCH               = \(String(format: "%016llx", combined) == "4bf581ead4d57139" ? "✅ byte-identical to CPU" : "❌ MISMATCH")")
diff --git a/docs/evidence/canon_quant.rs b/docs/evidence/canon_quant.rs
new file mode 100644
index 0000000000000000000000000000000000000000..da52aad82b524efada2ea9b74180487ef2bd41e8
--- /dev/null
+++ b/docs/evidence/canon_quant.rs
@@ -0,0 +1,139 @@
+// inc4b-1: offline canonical quantizer core — fp32 weights -> per-output-channel symmetric int8 with a
+// PINNED fixed-point scale (multiplier M0:i32, shift:i32), plus a minimal `.canon` container.
+// Floating point is used OFFLINE ONLY (this tool); the produced artifact is deterministic bytes that every
+// runtime backend consumes identically. This build runs a SELF-TEST on synthetic weights (no download):
+// it proves (a) determinism, (b) bounded round-trip error, (c) the fixed-point scale reconstructs the true
+// scale, (d) `.canon` write/read round-trips.
+//
+// Build/run:  rustc -O canon_quant.rs -o canon_quant && ./canon_quant
+
+use std::convert::TryInto;
+
+fn splitmix64(s: &mut u64) -> u64 {
+    *s = s.wrapping_add(0x9E3779B97F4A7C15);
+    let mut z = *s;
+    z = (z ^ (z >> 30)).wrapping_mul(0xBF58476D1CE4E5B9);
+    z = (z ^ (z >> 27)).wrapping_mul(0x94D049BB133111EB);
+    z ^ (z >> 31)
+}
+fn fnv(bytes: &[u8]) -> u64 {
+    let mut h: u64 = 0xcbf29ce484222325;
+    for &b in bytes { h ^= b as u64; h = h.wrapping_mul(0x100000001b3); }
+    h
+}
+
+// gemmlowp-style: real d>0  ->  (M0 in [2^30,2^31), shift)  with  d ≈ M0 * 2^(shift-31).
+fn quantize_multiplier(d: f64) -> (i32, i32) {
+    if d <= 0.0 { return (0, 0); }
+    let mut shift = 0i32;
+    let mut q = d;
+    while q >= 1.0 { q *= 0.5; shift += 1; }
+    while q < 0.5 { q *= 2.0; shift -= 1; }
+    let mut m0 = (q * (1i64 << 31) as f64).round() as i64; // q in [0.5,1) -> M0 in [2^30, 2^31]
+    if m0 == (1i64 << 31) { m0 >>= 1; shift += 1; }
+    (m0 as i32, shift)
+}
+fn scale_from_fixed(m0: i32, shift: i32) -> f64 { (m0 as f64) * 2f64.powi(shift - 31) }
+
+struct QTensor { out_ch: usize, in_ch: usize, w: Vec<i8>, m0: Vec<i32>, shift: Vec<i32> }
+
+// per-output-channel symmetric int8 quantization (round-half-away-from-zero, deterministic).
+fn quantize_perchannel(w: &[f32], out_ch: usize, in_ch: usize) -> QTensor {
+    let mut qw = vec![0i8; out_ch * in_ch];
+    let mut m0 = vec![0i32; out_ch];
+    let mut shift = vec![0i32; out_ch];
+    for c in 0..out_ch {
+        let row = &w[c * in_ch..(c + 1) * in_ch];
+        let amax = row.iter().fold(0f32, |a, &x| a.max(x.abs()));
+        let scale = if amax > 0.0 { (amax as f64) / 127.0 } else { 1.0 }; // dequant scale
+        let inv = if amax > 0.0 { 127.0 / (amax as f64) } else { 0.0 };
+        for k in 0..in_ch {
+            let v = (row[k] as f64) * inv;
+            let r = if v >= 0.0 { (v + 0.5).floor() } else { (v - 0.5).ceil() }; // half away from zero
+            qw[c * in_ch + k] = r.clamp(-127.0, 127.0) as i8;
+        }
+        let (mm, sh) = quantize_multiplier(scale);
+        m0[c] = mm; shift[c] = sh;
+    }
+    QTensor { out_ch, in_ch, w: qw, m0, shift }
+}
+
+// minimal `.canon` v0 container: magic + one tensor (out,in) + i8 weights + per-channel (M0,shift).
+fn write_canon(t: &QTensor) -> Vec<u8> {
+    let mut b = Vec::new();
+    b.extend_from_slice(b"CANONv0\n");
+    b.extend_from_slice(&(t.out_ch as u32).to_le_bytes());
+    b.extend_from_slice(&(t.in_ch as u32).to_le_bytes());
+    b.extend_from_slice(&t.w.iter().map(|&x| x as u8).collect::<Vec<u8>>());
+    for c in 0..t.out_ch { b.extend_from_slice(&t.m0[c].to_le_bytes()); b.extend_from_slice(&t.shift[c].to_le_bytes()); }
+    b
+}
+fn read_canon(b: &[u8]) -> QTensor {
+    assert_eq!(&b[0..8], b"CANONv0\n");
+    let out_ch = u32::from_le_bytes(b[8..12].try_into().unwrap()) as usize;
+    let in_ch = u32::from_le_bytes(b[12..16].try_into().unwrap()) as usize;
+    let wend = 16 + out_ch * in_ch;
+    let w: Vec<i8> = b[16..wend].iter().map(|&x| x as i8).collect();
+    let mut m0 = vec![0i32; out_ch]; let mut shift = vec![0i32; out_ch];
+    let mut p = wend;
+    for c in 0..out_ch {
+        m0[c] = i32::from_le_bytes(b[p..p + 4].try_into().unwrap()); p += 4;
+        shift[c] = i32::from_le_bytes(b[p..p + 4].try_into().unwrap()); p += 4;
+    }
+    QTensor { out_ch, in_ch, w, m0, shift }
+}
+
+fn main() {
+    // synthetic fp32 weight matrix [out=896, in=896] (a Qwen 0.5B proj-sized tensor), deterministic.
+    let (out_ch, in_ch) = (896usize, 896usize);
+    let mut s: u64 = 0x0000_0000_0051_4E54; // "QNT" seed
+    let w: Vec<f32> = (0..out_ch * in_ch).map(|_| {
+        let u = splitmix64(&mut s);
+        // map to ~N(0,0.05)-ish via two uniforms folded — offline fp is fine
+        let a = ((u & 0xFFFFFFFF) as f64) / (u32::MAX as f64) - 0.5;
+        let b = ((u >> 32) as f64) / (u32::MAX as f64) - 0.5;
+        ((a + b) * 0.1) as f32
+    }).collect();
+
+    let qt = quantize_perchannel(&w, out_ch, in_ch);
+
+    // (b) round-trip error: dequant and compare to original
+    let mut max_abs = 0f64; let mut sse = 0f64; let mut sxx = 0f64;
+    for c in 0..out_ch {
+        let sc = scale_from_fixed(qt.m0[c], qt.shift[c]);
+        for k in 0..in_ch {
+            let deq = qt.w[c * in_ch + k] as f64 * sc;
+            let orig = w[c * in_ch + k] as f64;
+            let e = (deq - orig).abs();
+            if e > max_abs { max_abs = e; }
+            sse += e * e; sxx += orig * orig;
+        }
+    }
+    let rms_rel = (sse / sxx).sqrt();
+
+    // (c) fixed-point scale reconstruction error (vs the true amax/127 per channel)
+    let mut max_scale_rel = 0f64;
+    for c in 0..out_ch {
+        let row = &w[c * in_ch..(c + 1) * in_ch];
+        let amax = row.iter().fold(0f32, |a, &x| a.max(x.abs())) as f64;
+        if amax > 0.0 {
+            let true_s = amax / 127.0;
+            let rec = scale_from_fixed(qt.m0[c], qt.shift[c]);
+            max_scale_rel = max_scale_rel.max(((rec - true_s) / true_s).abs());
+        }
+    }
+
+    // (a) determinism + (d) `.canon` round-trip
+    let bytes = write_canon(&qt);
+    let file_fnv = fnv(&bytes);
+    let qt2 = read_canon(&bytes);
+    let rt_ok = qt2.w == qt.w && qt2.m0 == qt.m0 && qt2.shift == qt.shift;
+
+    println!("tensor              = [{}, {}] int8, per-channel fixed-point scale", out_ch, in_ch);
+    println!("round-trip (dequant): max_abs_err={:.3e}  rms_rel_err={:.4}", max_abs, rms_rel);
+    println!("fixed-point scale rel err (max) = {:.2e}  (M0 is 31-bit -> ~ns precision)", max_scale_rel);
+    println!(".canon bytes        = {}   fnv={:016x}", bytes.len(), file_fnv);
+    println!(".canon round-trip   = {}", if rt_ok { "OK (weights+scales identical)" } else { "FAIL" });
+    println!("sample ch0: M0={} shift={} scale={:.6e}  w[0..6]={:?}",
+        qt.m0[0], qt.shift[0], scale_from_fixed(qt.m0[0], qt.shift[0]), &qt.w[0..6]);
+}
diff --git a/docs/evidence/canon_quant_full.py b/docs/evidence/canon_quant_full.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a19133fe845796d4f867725252c049e6c005f45
--- /dev/null
+++ b/docs/evidence/canon_quant_full.py
@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+# inc4b-1 full-model offline quantizer: safetensors (bf16) -> per-output-channel symmetric int8 with a
+# PINNED fixed-point scale (M0:i32, shift:i32), written into a `.canon` v1 container. Floating point is
+# used OFFLINE ONLY here; the emitted artifact is deterministic bytes consumed identically on every backend.
+# Canonical rounding: round-half-to-even (numpy default / IEEE). 2D tensors -> int8 per out-channel.
+# 1D tensors (norms/biases) -> stored as fixed-point int32 with one (M0,shift) (kept for the runtime).
+#
+# Usage:  python3 canon_quant_full.py model.safetensors out.canon
+
+import sys, json, struct, numpy as np
+
+def load_safetensors(path):
+    with open(path, "rb") as f:
+        n = struct.unpack("<Q", f.read(8))[0]
+        header = json.loads(f.read(n).decode("utf-8"))
+        data = f.read()
+    tensors = {}
+    for name, meta in header.items():
+        if name == "__metadata__":
+            continue
+        dt = meta["dtype"]; shape = meta["shape"]; s, e = meta["data_offsets"]
+        buf = data[s:e]
+        if dt == "BF16":
+            u16 = np.frombuffer(buf, dtype=np.uint16).astype(np.uint32)
+            arr = (u16 << 16).view(np.float32)
+        elif dt == "F16":
+            arr = np.frombuffer(buf, dtype=np.float16).astype(np.float32)
+        elif dt == "F32":
+            arr = np.frombuffer(buf, dtype=np.float32).copy()
+        else:
+            raise ValueError(f"dtype {dt} for {name}")
+        tensors[name] = (arr.reshape(shape), dt, shape)
+    return tensors
+
+def quantize_multiplier(scale):
+    # scale (float64 array > 0) -> (M0 int32, shift int32) with scale = M0 * 2^(shift-31)
+    m, e = np.frexp(scale)                 # scale = m * 2^e, m in [0.5,1)
+    M0 = np.round(m * (1 << 31)).astype(np.int64)
+    over = M0 == (1 << 31)
+    M0 = np.where(over, M0 >> 1, M0)
+    e = np.where(over, e + 1, e)
+    M0 = np.where(scale > 0, M0, 0).astype(np.int32)
+    shift = np.where(scale > 0, e, 0).astype(np.int32)
+    return M0, shift
+
+def quant_perchannel(W):
+    # W: [out, in] float32 -> int8 [out,in], (M0,shift)[out]
+    amax = np.max(np.abs(W), axis=1)
+    inv = np.where(amax > 0, 127.0 / amax, 0.0)
+    q = np.rint(W * inv[:, None])          # round-half-to-even
+    q = np.clip(q, -127, 127).astype(np.int8)
+    scale = np.where(amax > 0, amax / 127.0, 1.0).astype(np.float64)
+    M0, shift = quantize_multiplier(scale)
+    return q, M0, shift
+
+def main():
+    src, dst = sys.argv[1], sys.argv[2]
+    tensors = load_safetensors(src)
+    print(f"tensors: {len(tensors)}")
+    directory = []           # (name, kind, shape, w_off, w_len, s_off)
+    body = bytearray()
+    total_elems = 0
+    worst = []
+    for name in sorted(tensors.keys()):
+        arr, dt, shape = tensors[name]
+        total_elems += arr.size
+        if arr.ndim == 2:
+            q, M0, shift = quant_perchannel(arr.astype(np.float32))
+            # round-trip rms for reporting
+            sc = M0.astype(np.float64) * (2.0 ** (shift.astype(np.float64) - 31))
+            deq = q.astype(np.float64) * sc[:, None]
+            num = np.sum((deq - arr.astype(np.float64)) ** 2)
+            den = np.sum(arr.astype(np.float64) ** 2) + 1e-12
+            rms = float(np.sqrt(num / den))
+            worst.append((rms, name, list(shape)))
+            w_off = len(body); wbytes = q.tobytes(); body += wbytes
+            s_off = len(body)
+            for c in range(q.shape[0]):
+                body += struct.pack("<ii", int(M0[c]), int(shift[c]))
+            directory.append({"name": name, "kind": "w2d_int8_pcs", "shape": list(shape),
+                              "w_off": w_off, "w_len": len(wbytes), "s_off": s_off})
+        else:
+            # 1D (norm gamma / bias): fixed-point int32 with a single (M0,shift)
+            v = arr.astype(np.float64)
+            amax = float(np.max(np.abs(v))) if v.size else 0.0
+            scale = amax / (1 << 20) if amax > 0 else 1.0   # Q ~ 20-bit headroom
+            qi = np.rint(v / scale).astype(np.int32)
+            M0, shift = quantize_multiplier(np.array([scale]))
+            w_off = len(body); qb = qi.tobytes(); body += qb
+            s_off = len(body); body += struct.pack("<ii", int(M0[0]), int(shift[0]))
+            directory.append({"name": name, "kind": "v1d_int32_fp", "shape": list(shape),
+                              "w_off": w_off, "w_len": len(qb), "s_off": s_off})
+
+    header = {"format": "canon.v1", "model": "qwen2.5-0.5b", "rounding": "half-to-even",
+              "tensors": directory}
+    hb = json.dumps(header, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    with open(dst, "wb") as f:
+        f.write(b"CANONv1\n")
+        f.write(struct.pack("<Q", len(hb)))
+        f.write(hb)
+        f.write(body)
+
+    import hashlib
+    fb = open(dst, "rb").read()
+    h = hashlib.blake2b(fb, digest_size=16).hexdigest()
+    worst.sort(reverse=True)
+    print(f"params: {total_elems:,}")
+    print(f".canon: {len(fb):,} bytes  blake2b16={h}")
+    print("worst per-tensor rms (2D):")
+    for rms, name, shp in worst[:6]:
+        print(f"  {rms:.4f}  {name} {shp}")
+    print("best/median count:", len(worst), "2D tensors quantized")
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/evidence/canonical-int-attention-4b2a-2026-07-19.md b/docs/evidence/canonical-int-attention-4b2a-2026-07-19.md
new file mode 100644
index 0000000000000000000000000000000000000000..1c2c8970abab04a547f4efeb9a856c15c6973320
--- /dev/null
+++ b/docs/evidence/canonical-int-attention-4b2a-2026-07-19.md
@@ -0,0 +1,77 @@
+# Evidence — inc4b-2a integer attention block on real Qwen2.5-0.5B weights (2026-07-19)
+
+First integer-runtime piece for [inc4b](../canonical-integer-inc4b-fullmodel-design.md): a full attention
+block (layer 0) that consumes the real `.canon` W8A8 artifact and runs the whole path in integer —
+RMSNorm(isqrt) → Q/K/V int8 GEMM (+bias) → RoPE (fixed-point Q15 tables) → QK^T → integer softmax (exp-LUT)
+→ A·V → o_proj → residual. Validated against a full-fp reference computed from the **same dequantized
+weights**, to check the arithmetic is correct **before** the 3-backend byte-identity port (4b-2b).
+
+Script: `docs/evidence/canon_attn.py` (reads `docs/evidence/canon_dump.py`-inspectable `.canon`). Inputs are
+the real embedding rows for tokens `[9707, 11, 1879, 30]`, S=4 prefill.
+
+## Per-stage agreement (integer vs fp)
+
+| stage | int-vs-fp rel err | verdict |
+|---|---|---|
+| exp-LUT vs true `exp` (after bumping Horner 12→28 terms) | 0.0054 | accurate |
+| integer softmax vs fp softmax (same scores) | 0.020 | correct |
+| RoPE (int-dequant vs fp-rope, same q) | 0.024 | correct |
+| Q/K/V projection (int8 GEMM) vs fp projection | 0.023 | correct |
+| **attention out, W8 weights only, fp activations** | **0.0000** | **dataflow exactly correct** |
+| attention out, full W8A8 (per-tensor activation quant) | 0.361 | ← accuracy problem |
+
+## Findings
+
+1. **The integer attention block is wired exactly right.** With int8 **weights** (per-output-channel) but
+   fp activations, the attention output matches fp to **0.0000** — GEMM / GQA head mapping / RoPE / causal
+   mask / softmax / o_proj / residual are all correct. Per-channel int8 weights are ~lossless here.
+2. **Per-tensor int8 *activation* quantization is the whole error** (36%). The RMSNorm output (attention
+   input) has **outlier channels**; a single per-tensor scale is set by the outliers and crushes the normal
+   channels to near-zero → large relative error → amplified ~15× through the peaked softmax. This is the
+   well-known transformer activation-outlier problem, surfaced early.
+3. The exp-LUT from inc4a was *deterministic but inaccurate* at 12 Horner terms (poor near arg −4); 28 terms
+   fixes it (0.5%). Determinism was never in question — accuracy was.
+
+## Implications
+
+- **Determinism (the objective) is unaffected**: the block is all-integer and will be byte-identical across
+  backends (4b-2b) regardless of the quant scheme's *accuracy*.
+- **Usability needs a better activation quant**: per-tensor A8 is inadequate. Fix options: **SmoothQuant**
+  (migrate per-channel activation scale into the weights, keeping the int8 GEMM clean), per-channel/per-group
+  handling, or W8A16 activations. Per-token alone won't fix per-channel outliers.
+- The offline quantizer (4b-1) is fine as-is for weights; the activation-scale strategy is a runtime +
+  calibration decision to settle before the full 24-layer forward (else the model outputs garbage).
+
+## Accuracy fix (`docs/evidence/canon_attn_sq.py`)
+
+Chasing the 36% turned up the actual root cause — and it was **not** activation quant or softmax:
+
+1. **The integer RMSNorm had a precision bug.** `y = (Xq·inv) >> 16` right-shifted away all the fractional
+   bits, crushing the normalized activations to tiny integers (0,1,2). Keeping the normalized value in
+   high-precision fixed point (Q20: `y = Xq·isqrt(2^40/mean)`) fixes it. This single fix dropped W8A16 error
+   36% → 2.6%.
+2. **int16 activations (W8A16) resolve the outlier problem** without SmoothQuant tuning:
+
+   | config | attention out rel err |
+   |---|---|
+   | W8A8 per-tensor | 0.215 |
+   | W8A8 + SmoothQuant (α=0.5, untuned) | 0.211 |
+   | **W8A16 per-tensor** | **0.026** |
+   | W8A16 + fp-softmax | 0.017 (integer softmax adds ~1%) |
+
+3. Naive SmoothQuant (α=0.5, tiny calibration) barely helped here — it needs real calibration/tuning. W8A16
+   is the simpler, robust choice: int8 weight × int16 activation → int64 accumulate stays fully integer
+   (deterministic), and 16-bit range holds the outlier channels without crushing the rest.
+
+**Conclusion**: with the RMSNorm-precision fix + **W8A16**, the integer attention block is accurate (2.6%)
+AND deterministic. W8A8 (int8 activations, tensor-core-friendly) would need tuned SmoothQuant — a later perf
+optimization. Determinism was never in question; the work here was accuracy.
+
+## Honest scope
+
+- Scalar activation scales are carried as fp here (correctness cut); the 4b-2b port makes them fixed-point
+  and proves byte-identity on CPU/Metal/CUDA.
+- Single (S=4) prompt, layer 0 only. 2.6%/block is usable; the compounded token-match vs fp over 24 layers
+  is measured in 4b-4/4b-5.
+- int8×int16 is not a standard tensor-core op, so W8A16 runs on the regular integer ALU (determinism intact,
+  lower throughput). W8A8 + tuned SmoothQuant recovers tensor cores later if needed.
diff --git a/docs/evidence/canonical-int-attention-4b2b-2026-07-19.md b/docs/evidence/canonical-int-attention-4b2b-2026-07-19.md
new file mode 100644
index 0000000000000000000000000000000000000000..d72ca554adac3fd592e0acf35979a44c5a6fa786
--- /dev/null
+++ b/docs/evidence/canonical-int-attention-4b2b-2026-07-19.md
@@ -0,0 +1,53 @@
+# Evidence — inc4b-2b: integer attention block byte-identical across CPU (×2 ISA) + NVIDIA CUDA GPU (2026-07-19)
+
+The fully-integer attention block (Qwen2.5-0.5B layer 0), consuming the **real** `.canon` W8A16 artifact, is
+**byte-identical across four implementations on real hardware** — the first end-to-end "same integer
+computation, same bits, different vendor" demonstration on a real transformer block.
+
+## What runs
+
+All scales are **Q30 fixed-point integers**; there is **no floating point on the compute path** (RMSNorm
+uses integer `isqrt`, RoPE uses pinned Q15 tables, softmax uses an integer exp-LUT). The block:
+`RMSNorm → Q/K/V int8 GEMM (+bias, W8A16) → RoPE → QK^T → integer softmax → A·V → o_proj → residual`.
+
+- **Reference** `docs/evidence/canon_attn_int.py` (Python, arbitrary-precision ints) — defines the spec and
+  the target fingerprint (FNV over the int64 block output). Accuracy vs fp = **3.78%** (usable).
+- **Extractor** `docs/evidence/canon_extract.py` — pulls the 9 layer-0 tensors + the test-token embedding
+  rows + RoPE/EXP tables from `qwen05.canon` into a flat `layer0.bin` (so standalone builds need no JSON).
+- **Rust** `docs/evidence/canon_attn.rs` — `i128` scales, `i64` values, explicit floor-division to match
+  Python's `//`. This is the CPU runtime.
+- **CUDA** `docs/evidence/canon_attn.cu` — host parses, a single-thread `__global__` kernel runs the block
+  on the GPU with `__int128` scales.
+
+## Results — one fingerprint, four implementations
+
+| implementation | hardware | ISA / arch | block-out FNV |
+|---|---|---|---|
+| Python reference | RTX box | x86_64 | `dea9a75ba85b1352` |
+| Rust CPU | RTX box | x86_64 | `dea9a75ba85b1352` |
+| Rust CPU | Mac | **aarch64** | `dea9a75ba85b1352` |
+| **CUDA GPU** | RTX 4060 Ti | **Ada sm_89** | `dea9a75ba85b1352` |
+
+Block output `hout[0..4] = [-81, 33, -21, 30]` on all four.
+
+## Reading
+
+- A **real** transformer attention block (real Qwen2.5-0.5B weights, not a synthetic primitive) produces
+  **byte-identical output on Apple aarch64 CPU, x86 CPU, and NVIDIA Ada GPU**. This is "Mac attention verified
+  on CUDA" — the cross-vendor determinism the canonical-integer path exists to deliver, now shown end-to-end
+  on a whole block, not just per-op.
+- The i128 scale arithmetic is deterministic across Rust (`i128`) and CUDA (`__int128`); the integer floor
+  division + arithmetic shifts match exactly.
+
+## Honest scope / what remains
+
+- **Metal GPU port is not done.** Metal Shading Language has no 128-bit integer (`long` = i64 max). The
+  current formulation lets Q30 scales grow to ~2^49, so products need i128 — this must be **refactored to a
+  bounded (m0, shift) representation** so all arithmetic fits i64 before Metal can join. The Apple **CPU**
+  (aarch64) already matches here, so Apple *hardware* is covered; the Apple **GPU** specifically needs that
+  refactor.
+- Single-thread CUDA kernel (S=4 is tiny); a parallel-reduction/tensor-core version is a perf follow-up
+  (determinism unaffected — integer associativity).
+- Layer 0, one prompt. Next: **4b-3** (full transformer layer = this attention block + SwiGLU MLP + 2nd
+  RMSNorm), **4b-4** (all 24 layers + LM head + argmax → token commitment), **4b-5** (token-match vs fp +
+  wire a `canonical` class into the verifier).
diff --git a/docs/evidence/canonical-int-cross-isa-2026-07-19.md b/docs/evidence/canonical-int-cross-isa-2026-07-19.md
new file mode 100644
index 0000000000000000000000000000000000000000..e72dfa29686428354907109def705ca4cdcc0043
--- /dev/null
+++ b/docs/evidence/canonical-int-cross-isa-2026-07-19.md
@@ -0,0 +1,61 @@
+# Evidence — Canonical integer compute is order- and ISA-independent (2026-07-19)
+
+First-party run record backing [`docs/canonical-integer-compute-design.md`](../canonical-integer-compute-design.md)
+§4. Demonstrates the core theorem on **two real, different CPU ISAs**: an `int8×int8→int32` GEMM is
+byte-identical across reduction orders and across `aarch64` (Apple) vs `x86_64` (the NVIDIA/WSL2 host),
+while the same computation in fp32 diverges across reduction orders.
+
+## Artifact
+
+`docs/evidence/canon_int.rs` — dependency-free Rust. Generates identical `int8` inputs on both machines via
+a fixed splitmix64 seed, computes a `32×8192×32` GEMM two ways (sequential vs pairwise-tree reduction) in
+both `int32` and `f32`, applies a fixed-point requantization to `int8`, and prints an FNV-1a fingerprint of
+each. Build/run:
+
+```sh
+rustc -O canon_int.rs -o canon_int && ./canon_int
+```
+
+## Results
+
+**Mac (Apple, aarch64):**
+```
+arch                = aarch64
+shape M,K,N         = 32,8192,32
+INT  seq  fnv       = 4b138ed70d137781
+INT  tree fnv       = 4b138ed70d137781
+INT  order-invariant= MATCH  ✅ (hardware-independent)
+FP32 seq  fnv       = 9019ee04ee549e3e
+FP32 tree fnv       = e68f80da326d710d
+FP32 order-invariant= DIFFER ⚠️  (order-dependent → hardware-dependent)
+CANONICAL commitment= 743652581b0b9725
+```
+
+**RTX box (NVIDIA host, x86_64, WSL2):**
+```
+arch                = x86_64
+shape M,K,N         = 32,8192,32
+INT  seq  fnv       = 4b138ed70d137781
+INT  tree fnv       = 4b138ed70d137781
+INT  order-invariant= MATCH  ✅ (hardware-independent)
+FP32 seq  fnv       = 9019ee04ee549e3e
+FP32 tree fnv       = e68f80da326d710d
+FP32 order-invariant= DIFFER ⚠️  (order-dependent → hardware-dependent)
+CANONICAL commitment= 743652581b0b9725
+```
+
+## Reading
+
+- **INT canonical commitment `743652581b0b9725` is byte-identical on aarch64 and x86_64** — and identical
+  under two different reduction orders. This is the `int32`-ring associativity guarantee, on real hardware.
+- **fp32 diverges across reduction orders** (`9019ee04…` seq vs `e68f80da…` tree). Different GPU kernels /
+  tensor-core generations = different reduction orders = different bits. This is exactly why RTX 20 (`sm_75`)
+  and RTX 40 (`sm_89`) cannot be assumed to share an fp class.
+
+## Honest scope
+
+- This is **CPU** integer arithmetic across two ISAs. It proves the math (order/ISA independence) but does
+  **not** yet exercise a **GPU int8 kernel** — that is increment 2 in the design doc (custom CUDA + Metal
+  int8 GEMM, then bit-identity across CPU / Metal / CUDA-Ada). By the theorem, GPU parallel reductions fall
+  under the same invariance, but that must still be demonstrated on device.
+- No Turing (`sm_75`) hardware was available here; the final RTX 20 bit-identity check is a user HW step.
diff --git a/docs/evidence/canonical-int-fulllayer-4b3-2026-07-20.md b/docs/evidence/canonical-int-fulllayer-4b3-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..2010f08aae9c0fcf85f7ca22ff337885c4606050
--- /dev/null
+++ b/docs/evidence/canonical-int-fulllayer-4b3-2026-07-20.md
@@ -0,0 +1,52 @@
+# Evidence — inc4b-3: fully-integer full transformer layer (reference) (2026-07-20)
+
+Extends the attention block (4b-2b) to a **complete Qwen2.5-0.5B transformer layer**, fully integer, no fp on
+the compute path: `RMSNorm → attention → residual → RMSNorm → SwiGLU MLP → residual`.
+
+Reference: `docs/evidence/canon_layer_int.py` (Python, arbitrary-precision int; the spec + target fingerprint).
+
+## New this increment (the MLP sub-block)
+
+- **2nd RMSNorm** (`post_attention_layernorm`) — same integer isqrt RMSNorm as attention (scale-invariant).
+- **gate / up projections** — int8 GEMM, W8A16, per-channel scale, requant (no bias, as Qwen2 SwiGLU).
+- **integer SiLU** `act = gate · sigmoid(gate)` — via a **pinned sigmoid LUT** (4096 entries, Q16; sigmoid is
+  bounded so a LUT works, unlike unbounded SiLU). Index `= round(gate_true·128)+2048` computed in fixed point.
+- **`hmul = act · up`** — elementwise integer multiply + requant.
+- **down projection** — int8 GEMM → residual add into the attention output.
+
+### Bug found + fixed: scale underflow in the SiLU chain
+`act = gate·sig` makes the values large (~2³¹) and the per-unit scale tiny (`gate_sq · 2⁻¹⁶`), which
+**underflows to 0** in Q30 when `gate_sq < 2¹⁶`, collapsing all downstream scales (`cmax=0`, div-by-zero).
+Fix: **requant `act` to int16 immediately**, computing its scale as `scale_from(amax, gate_sq) >> 16` — the
+large `amax` is multiplied in *before* the `>>16`, so the scale stays healthy (aq recovers a ~2⁻¹⁵ scale). The
+same "requant to keep values in int16 range and let aq recompute the scale" discipline is what keeps every
+stage's Q30 scale representable.
+
+## Result
+
+```
+FULL LAYER: accuracy vs fp = 0.0372        # 3.72%, ~unchanged from attention-only 3.78% (MLP adds ~0)
+layer-out FNV = 906729150a5a926a           # Rust/CUDA ports must reproduce
+layer[0,:4] int = [202, 187, 603, -177]
+```
+
+## Ports — DONE (4-way byte-identical)
+
+The full transformer layer is byte-identical `906729150a5a926a` across four implementations (`layer[0..4]=[202,187,603,-177]`):
+
+| implementation | hardware | ISA / arch | layer-out FNV |
+|---|---|---|---|
+| Python reference | RTX box | x86_64 | `906729150a5a926a` |
+| Rust CPU | RTX box | x86_64 | `906729150a5a926a` |
+| Rust CPU | Mac | aarch64 | `906729150a5a926a` |
+| CUDA GPU | RTX 4060 Ti | Ada sm_89 | `906729150a5a926a` |
+
+Files: `docs/evidence/canon_extract.py` (now emits `post_attention_layernorm` + `mlp.gate/up/down` + sigmoid
+LUT), `canon_attn.rs` / `canon_attn.cu` (added `rmsnorm`/`proj_nb` + the MLP block). CUDA note: `projd` takes a
+nullable bias pointer; the `up()` upload lambda must be split by pointer type (i64* / signed char* / i128*).
+
+## Honest scope / what remains
+- Metal still needs the i128→i64 scale refactor (unchanged from 4b-2b).
+- After the ports: **4b-4** — stack all 24 layers (loop this layer, threading the residual stream) + final
+  RMSNorm + tied LM head + argmax → the backend-independent **token** commitment; then **4b-5** (token-match
+  vs fp + wire a `canonical` class into the verifier).
diff --git a/docs/evidence/canonical-int-fullmodel-4b4-4b5-2026-07-20.md b/docs/evidence/canonical-int-fullmodel-4b4-4b5-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..cdf4de36d9d0f392262a69bd976a87457a9e1e5e
--- /dev/null
+++ b/docs/evidence/canonical-int-fullmodel-4b4-4b5-2026-07-20.md
@@ -0,0 +1,56 @@
+# Evidence — inc4b-4 / 4b-5: full 24-layer integer forward + token commitment + fp agreement (2026-07-20)
+
+Extends the full layer (4b-3) to the **whole Qwen2.5-0.5B**: 24 layers + final RMSNorm + tied LM head +
+integer argmax, with greedy decode. Fully integer, no fp on the compute path (`docs/evidence/canon_model_int.py`).
+
+## 4b-4 — backend-independent token commitment
+
+```
+prompt = [9707, 11, 1879, 30]
+integer generated = [3555, 1558, 432, 3076, 30, 1084]   # greedy, 6 tokens
+TOKEN COMMITMENT (blake2b16, over the generated ids) = 92a5380b0d1be4b126a2464d915243c8   (NDECODE=6)
+                                                        b4a092dad65655c7def87f11a6ed0df7   (NDECODE=4)
+```
+
+- **Backend independence** holds **by composition**: the full model is 24 stacked copies of the 4b-3 layer
+  (proven byte-identical across Python-x86 / Rust-x86 / Rust-aarch64 / CUDA-Ada) + final RMSNorm + an int8
+  LM-head GEMM + integer argmax (all proven byte-identical). Given identical pinned tables (RoPE per position,
+  sigmoid/exp LUTs), the whole forward — and thus the token commitment — is identical on every backend.
+- LM-head argmax weights each vocab logit by its per-row int8 scale (fixed-point) before the integer argmax,
+  so it is exact and deterministic.
+- A concrete full-model **Rust/CUDA run** would need all 24 layers' weights + the 151936×896 embedding
+  (~634 MB flat) extracted and uploaded; deferred. The layer-level 4-way byte-identity (4b-3) already
+  establishes the composition.
+
+## 4b-5 — fidelity to fp (token agreement): the honest result
+
+```
+integer generated = [3555, 1558, 432, 3076, 30, 1084]
+fp      generated = [3555,  374, 279, 7290, 315,  279]
+token agreement (int vs fp) = 1/6
+```
+
+- **Only the first token matches.** The single-layer W8A16 error (~3.7%, from 4b-2a/4b-3) **compounds across
+  24 layers** and flips the greedy argmax from token 2 onward. So the canonical integer model is a
+  **distinct, lower-fidelity model** than the fp reference — deterministic and vendor-independent, but not
+  tracking fp's output.
+- This is **not a determinism failure** (the commitment reproduces across backends). It is a **quality**
+  finding: per-tensor W8A16 is too coarse for a 24-layer greedy decode. To make the canonical class track fp
+  / produce high-quality text, higher-fidelity quantization is needed — per-channel activation handling
+  (SmoothQuant), W16A16, or better calibration. This is the standard "naive PTQ degrades deep models" result.
+
+## Status of the canonical class
+
+- **Determinism / backend-independence: achieved** (per-op → per-layer → full-model, all byte-identical).
+  This is the property the canonical-integer path exists to deliver, and it is demonstrated end-to-end.
+- **Fidelity / usable quality: not yet** — needs a better quantization scheme (above). The class is a
+  correct proof-of-concept; its *golden tokens* are its own, distinct from any fp class, and currently
+  low-fidelity vs fp.
+
+## Honest scope / what remains
+
+- Improve quantization fidelity (SmoothQuant / W16A16 / calibration) so the 24-layer greedy decode tracks fp,
+  then re-measure token agreement.
+- Full-model Rust/CUDA run (concrete end-to-end cross-backend token-commitment match) — deferred on weight
+  size; backend-independence already established by the layer-level byte-identity.
+- Metal port still needs the i128→i64 scale refactor.
diff --git a/docs/evidence/canonical-int-gpu-3backend-2026-07-19.md b/docs/evidence/canonical-int-gpu-3backend-2026-07-19.md
new file mode 100644
index 0000000000000000000000000000000000000000..033c07742e1657dc3d340a93149a71398aa57f00
--- /dev/null
+++ b/docs/evidence/canonical-int-gpu-3backend-2026-07-19.md
@@ -0,0 +1,58 @@
+# Evidence — Canonical int8 GEMM is byte-identical across CPU / Apple Metal / NVIDIA CUDA (2026-07-19)
+
+Increment 2 of [`docs/canonical-integer-compute-design.md`](../canonical-integer-compute-design.md). Extends
+the CPU-only cross-ISA result ([canonical-int-cross-isa](canonical-int-cross-isa-2026-07-19.md)) onto **real
+GPUs of two different vendors**. The same `int8×int8→int32` GEMM (same splitmix64 inputs, `M,K,N=32,8192,32`,
+values `0..127`) is computed on each backend and fingerprinted identically (int32 little-endian → FNV-1a 64).
+
+## Artifacts (all in `docs/evidence/`)
+
+| backend | source | build |
+|---|---|---|
+| CPU (reference) | `canon_int.rs` | `rustc -O canon_int.rs` |
+| Apple Metal GPU | `canon_metal.swift` | `swiftc -O canon_metal.swift` |
+| NVIDIA CUDA GPU | `canon_cuda.cu` | `nvcc -O3 -arch=sm_89 canon_cuda.cu` |
+
+## Results — one fingerprint, four backends
+
+| backend | hardware | ISA / arch | INT fnv |
+|---|---|---|---|
+| CPU | Apple M1 Max | aarch64 | `4b138ed70d137781` |
+| CPU | NVIDIA/WSL2 host | x86_64 | `4b138ed70d137781` |
+| Apple Metal GPU | Apple M1 Max | Apple GPU | `4b138ed70d137781` |
+| NVIDIA CUDA GPU | RTX 4060 Ti | Ada `sm_89` | `4b138ed70d137781` |
+
+Raw GPU runs:
+
+```
+# Apple Metal (Mac)
+backend             = Apple Metal GPU (Apple M1 Max)
+INT  gpu  fnv       = 4b138ed70d137781
+MATCH               = ✅ byte-identical to CPU
+
+# NVIDIA CUDA (RTX box, WSL2, nvcc 12.6, -arch=sm_89)
+backend             = NVIDIA CUDA GPU (NVIDIA GeForce RTX 4060 Ti, sm_89)
+INT  gpu  fnv       = 4b138ed70d137781
+MATCH               = OK byte-identical
+```
+
+## Reading
+
+- The canonical integer GEMM is byte-identical across **two CPU ISAs and two GPU vendors/microarchitectures**
+  — Apple GPU ≡ NVIDIA Ada ≡ x86 CPU ≡ ARM CPU. This is the cross-vendor invariance that the token
+  `vector_commitment` needs in order for different hardware to share a determinism/pool class.
+- Contrast with the fp reality measured on the same hardware: the fp32 verifier's token commitment CHANGED
+  merely from a candle 0.9.2→0.11 bump on CUDA (Ada), and Apple vs NVIDIA already diverge. Integer removes
+  that divergence by construction.
+
+## Honest scope / what remains
+
+- These kernels use one thread per output with a sequential `k`-loop; order-independence of parallel
+  reductions is proven separately on CPU (seq vs tree, [cross-isa evidence](canonical-int-cross-isa-2026-07-19.md))
+  and follows from `int32`-ring associativity. A tensor-core / split-K variant would exercise parallel GPU
+  reduction directly — a good hardening follow-up.
+- **Turing (`sm_75`, RTX 20/16) is still unrun here** (no Turing GPU). By the theorem it must also produce
+  `4b138ed70d137781`; confirming it on a real RTX 2060 is the user HW step that lets RTX 20/16 join the Ada
+  class (design doc increment 6).
+- This is the GEMM **primitive**. A full model still needs the canonical requant / LUT nonlinearities /
+  softmax / argmax of design §3 (increments 3–5) before a whole-model token commitment is backend-independent.
diff --git a/docs/evidence/canonical-int-hifi-fullmodel-2026-07-20.md b/docs/evidence/canonical-int-hifi-fullmodel-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..6f420b600c4a166652f394d390bc91927ba1bc58
--- /dev/null
+++ b/docs/evidence/canonical-int-hifi-fullmodel-2026-07-20.md
@@ -0,0 +1,58 @@
+# Evidence — hifi canonical integer model: fp と 12/12 一致 + full-model 4 実装一致 (2026-07-20)
+
+前回の正直な課題(4b-5: token 一致 1/6)を**解決**し、full-model の Rust/CUDA 具現ランまで完了した記録。
+
+## 1. 忠実度修正 — 1/6 → **12/12**
+
+原因は量子化方式ではなく**粒度と分解能**だった。hifi 構成(`docs/evidence/canon_model_hifi.py`):
+
+| 変更 | before | after |
+|---|---|---|
+| 活性ビット幅 | A16(ALVL=32767) | **A24**(ALVL=2²³−1) |
+| スケール固定小数点 | Q30(小スケール積が underflow) | **Q60**(underflow 消滅) |
+| exp LUT | 256 エントリ・1/64 刻み | **2048・1/512 刻み** |
+| sigmoid LUT | 4096・1/128 刻み | **16384・1/512 刻み** |
+
+結果(実 bf16→W8 量子化重み、prompt `[9707,11,1879,30]`、greedy):
+
+```
+integer = [3555, 374, 279, 7290, 315, 279, 17133, 330, 9707, 11, 1879, 7521]
+fp      = [3555, 374, 279, 7290, 315, 279, 17133, 330, 9707, 11, 1879, 7521]
+token agreement = 12/12
+TOKEN COMMITMENT (blake2b16, 12 tok) = 2e911f7973bbaedfb4ff653899f673f0   (6 tok: 7f58ee97d9f6fdea0bb2e73c874a30c8)
+```
+
+**per-tensor W8 のままで fp を追跡できた** — SmoothQuant/W16 は不要だった(この prompt 長では)。
+教訓 2 件: (a) Q30 は小スケール積で 0 に潰れる(4b-2a の RMSNorm バグと同族の**表現力問題**)— Q60 か
+正規化 (m0,shift) が必須。(b) numpy int64 は A24 の中間積で**サイレント wrap**する — 参照は object/int
+の exact 経路に(ports は i128 で元々安全)。
+
+## 2. full-model 具現ラン — 4 実装・実ハードで同一 token
+
+抽出器 `canon_extract_full.py` が qwen05.canon → `model.bin`(498,080,914 bytes、blake2b16
+`ead451ef79e88a2db5518f3d371722e9`、24 層 + embed + final norm + RoPE/EXP/SIG テーブル)を生成。
+Rust port `canon_model.rs`(i128 スケール)と CUDA run `canon_model.cu`(**全 GEMM = 7×24 + LM head を
+GPU がオンデバイス実行**、整数グルーは host __int128 — 全段整数なので決定性は同一)を実行:
+
+| 実装 | hardware | generated (6 tok) | ids FNV | time |
+|---|---|---|---|---|
+| Python 参照 | x86_64 | `[3555, 374, 279, 7290, 315, 279]` | — (commitment 7f58ee97…) | ~45s |
+| Rust CPU | x86_64 | 同上 | `65d2e3adaf2dce9e` | 9.5s |
+| Rust CPU | **aarch64 (Mac)** | 同上 | `65d2e3adaf2dce9e` | 7.0s |
+| **CUDA** | **RTX 4060 Ti (Ada)** | 同上 | `65d2e3adaf2dce9e` | **1.4s** |
+
+- model.bin は Mac へバイト検証付き転送(blake2b16 一致)— 全実装が**同一成果物**を消費。
+- 生成 token 列は **fp と 6/6 一致する系列そのもの** — つまり canonical integer class は「決定的・
+  vendor 非依存・かつ fp 品質を追跡」の 3 点を同時に満たした。
+
+## 3. 正直な限界
+
+- token 一致は 1 prompt × 12 token(+6 token 構成でも一致)での確認。golden 化前に複数 prompt・長系列
+  での一致率測定(canary 的サンプリング)を推奨。低マージン手ではいずれ分岐し得る(それは class の
+  定義上は問題ではないが、fp 品質の同等性主張には影響)。
+- CUDA ランは「GPU が全 GEMM を実行 + host が整数グルー」構成。全 stage を単一 GPU カーネル化する
+  full-device 版は未実施(決定性の主張には影響なし — 全段整数)。
+- Apple **GPU**(Metal)は未実施のまま(i128→i64 正規化 refactor が前提、設計は design doc §7 参照)。
+  Apple **CPU**(aarch64)は本記録で full-model 一致済み。
+- Python 参照の RoPE/SIG テーブル生成はオフライン fp(テーブル自体は pin されるので runtime 決定性に
+  影響なし — 生成一致は extractor が単一ソースであることで担保)。
diff --git a/docs/evidence/canonical-int-layer-4backend-2026-07-19.md b/docs/evidence/canonical-int-layer-4backend-2026-07-19.md
new file mode 100644
index 0000000000000000000000000000000000000000..705e268b8bdf064a938651ce175b702f80b2af0f
--- /dev/null
+++ b/docs/evidence/canonical-int-layer-4backend-2026-07-19.md
@@ -0,0 +1,59 @@
+# Evidence — Canonical integer LAYER is byte-identical across CPU / Metal / CUDA (2026-07-19)
+
+Increment 3 of [`docs/canonical-integer-compute-design.md`](../canonical-integer-compute-design.md). Extends
+the GEMM primitive ([increment 2](canonical-int-gpu-3backend-2026-07-19.md)) to a **full quantized layer**
+that includes the two stages where floating point normally sneaks back in — **requantization** and the
+**nonlinearity** — and shows the whole layer is still byte-identical across four backends.
+
+## The layer (no fp on the compute path)
+
+For each output `(i,j)`:
+1. `acc = Σ_t X[i,t]·W[t,j]` — int8×int8 → **int32** GEMM.
+2. `pre = acc + bias[j]` — int32 bias (per output channel).
+3. **fixed-point requant** `q = clamp((pre·M0[j] + 2^(shift-1)) >> shift, -127, 127)` — integer mul (int64)
+   + shift, gemmlowp/TFLite style. **No fp divide.** (`M0[j]` per-channel multiplier, `shift=20`.)
+4. **pinned integer LUT** `out = LUT[q + 128]` — a 256-entry int8→int8 table for a fast-sigmoid SiLU,
+   generated by integer-only arithmetic (truncating division, identical in Rust/CUDA/Metal). **No on-device
+   `expf`/`sigmoid` fp.**
+
+`M,K,N = 16,2048,16`; inputs and per-channel params from fixed splitmix64 seeds. Fingerprint = FNV-1a 64 over
+the int8 output (and separately over the LUT, to confirm the pinned table is identical everywhere).
+
+## Artifacts (`docs/evidence/`)
+
+| backend | source | build |
+|---|---|---|
+| CPU (reference) | `canon_layer.rs` | `rustc -O canon_layer.rs` |
+| Apple Metal GPU | `canon_layer_metal.swift` | `swiftc -O canon_layer_metal.swift` |
+| NVIDIA CUDA GPU | `canon_layer_cuda.cu` | `nvcc -O3 -arch=sm_89 canon_layer_cuda.cu` |
+
+## Results
+
+| backend | hardware | ISA / arch | LUT fnv | LAYER fnv |
+|---|---|---|---|---|
+| CPU | Mac | aarch64 | `8ab2052fcf2b005a` | `440bd1b93d991fe0` |
+| CPU | RTX host (WSL2) | x86_64 | `8ab2052fcf2b005a` | `440bd1b93d991fe0` |
+| Apple Metal GPU | M1 Max | Apple GPU | `8ab2052fcf2b005a` | `440bd1b93d991fe0` |
+| NVIDIA CUDA GPU | RTX 4060 Ti | Ada `sm_89` | `8ab2052fcf2b005a` | `440bd1b93d991fe0` |
+
+Post-requant `q` spans the full `[-127, 127]` (mean ~85) — the output is non-degenerate, so the LUT and
+requant are genuinely exercised, not collapsed to a constant.
+
+## Reading
+
+- A quantized layer **including requant and a nonlinearity** is byte-identical across two CPU ISAs and two
+  GPU vendors. The two classic fp-reinjection points are closed: requant is integer mul+shift (not fp
+  divide), and the nonlinearity is a pinned integer table lookup (not an on-device transcendental).
+- Combined with increment 2 (GEMM), this is every op type a transformer FFN block needs, all backend-
+  independent. The remaining model-level work (increment 4) is composing these into the full dense
+  Qwen2.5-0.5B forward (attention softmax, RMSNorm rsqrt, embedding) under the same integer discipline.
+
+## Honest scope
+
+- Kernels are one-thread-per-output with a sequential `k`-loop; parallel-reduction order-independence is
+  covered by the CPU seq-vs-tree proof + int32 associativity (increment 1). A tensor-core / split-K variant
+  is a hardening follow-up.
+- The LUT here is a demonstrator fast-sigmoid SiLU, defined by integer arithmetic so the table is identical
+  on every host without baking bytes. A production spec would pin the exact table (and the exact requant
+  multipliers/shifts) as part of the model artifact.
+- No Turing (`sm_75`) run here; by the theorem it must also yield `440bd1b93d991fe0` (user HW step).
diff --git a/docs/evidence/canonical-int-metal-norm-2026-07-20.md b/docs/evidence/canonical-int-metal-norm-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..650c7908d79aef6eac231747f7bcf97f035c47ce
--- /dev/null
+++ b/docs/evidence/canonical-int-metal-norm-2026-07-20.md
@@ -0,0 +1,35 @@
+# Evidence — Metal GPU 参加: (m0,e)+mulhi norm プロファイルで 3 実装ビット一致 (2026-07-20)
+
+design doc §8 の i128→i64 refactor を実装・実証した記録。MSL には 128-bit 整数が無いため、
+**全スケールを正規化 (m0∈[2^30,2^31), e) 表現**にし、値×スケールは **32-bit limb の 2-word 乗算 +
+2-word シフト**(= MSL がネイティブに書ける演算のみ)で行う「norm プロファイル」を定義した。
+
+## 実装
+
+- `canon_attn_norm.rs` — Rust 参照(i64 演算 + limb 乗算のみ。i128 不使用 — MSL へ**逐語訳可能**)。
+  sc_mul: `m0a·m0b < 2^62`(i64 内)→ `>>31`; sc_ratio: `(m0a<<31)/m0b`; apply_sc: mul64_wide + 2-word
+  shift、round-half-away; aq: `(2·ax·ALVL+am)/(2am)`。
+- `canon_attn_norm.swift` — Swift host(layer0.bin パース + gemmlowp→(m0,e) 変換)+ 単一スレッド MSL
+  カーネル(全層: RMSNorm→QKV+bias→RoPE→scores→整数 softmax→A·V→o_proj→residual→RMSNorm→SwiGLU→residual)。
+
+丸め位置が Q30/Q60 プロファイルと異なるため、このプロファイルは**独自のリファレンス値**を持つ
+(クレームはクロスバックエンド同一性)。
+
+## 結果 — 3 実装ビット一致
+
+| 実装 | hardware | layer FNV | layer[0..4] |
+|---|---|---|---|
+| Rust CPU | x86_64 (RTX box) | `50a8caf4107f43f4` | [265, 210, 581, -123] |
+| Rust CPU | aarch64 (Mac) | `50a8caf4107f43f4` | 同一 |
+| **Apple Metal GPU** | **M1 Max** | `50a8caf4107f43f4` | 同一 |
+
+→ **Apple GPU が整数 canonical プールに参加**(初回コンパイルで一致)。既プロファイルと合わせ、
+実重み transformer 層のビット一致実証は CPU×2 ISA + NVIDIA GPU(Q30/Q60)+ **Apple GPU(norm)** に到達。
+
+## 正直な範囲
+
+- norm プロファイルは Q30 プロファイル(`906729150a5a926a`)と**値が異なる**(丸め差、出力は近傍)。
+  プール統合には全 backend を norm プロファイルに揃えるのが本線(CUDA の norm 移植は limb コードの
+  逐語コピーで機械的 — 未実施)。
+- 単一スレッドカーネル(S=4)。並列化は integer 結合律で安全(inc1 実証)だが perf 作業は別。
+- full-model の norm 版・A24/Q60 相当の hifi 化(sc の 2^e 精度は同等以上なので適用可能)は次段。
diff --git a/docs/evidence/canonical-int-ops-4backend-2026-07-19.md b/docs/evidence/canonical-int-ops-4backend-2026-07-19.md
new file mode 100644
index 0000000000000000000000000000000000000000..d4b83ae62925446e600f8648fcd7bbd28ef95972
--- /dev/null
+++ b/docs/evidence/canonical-int-ops-4backend-2026-07-19.md
@@ -0,0 +1,62 @@
+# Evidence — Canonical integer softmax / RMSNorm / argmax across CPU / Metal / CUDA (2026-07-19)
+
+Increment 4a of [`docs/canonical-integer-compute-design.md`](../canonical-integer-compute-design.md). Covers
+the **remaining transcendental-bearing transformer ops** — attention **softmax** (needs `exp`) and
+**RMSNorm** (needs `rsqrt`) — plus **argmax**, all in integer arithmetic with **no floating point**, and
+shows them byte-identical across four backends. With increments 2 (GEMM) and 3 (bias/requant/LUT), this
+completes backend-independence for **every op type a dense transformer forward uses**.
+
+## The ops (no fp on the compute path)
+
+- **softmax** over int32 scores: subtract max (int); `exp(-d)` via a **pinned fixed-point `exp` table**
+  (Q16, generated by integer Horner — 12 terms — so the table is identical on every host, no libm `exp`);
+  sum in `uint64`; normalize `p_i = (e_i << 16) / sum` by integer division. No fp.
+- **RMSNorm** over int32: `Σx²` in `int64`; `mean`; **integer `rsqrt`** via `isqrt((1<<32)/mean)` where
+  `isqrt` is integer Newton (no fp, no fast-inverse-sqrt bit trick); scale by per-channel γ with a fixed
+  shift. No fp.
+- **argmax**: integer compare, deterministic first-max tie-break.
+
+`L=1024` (softmax/argmax), `H=896` (RMSNorm, Qwen-0.5B hidden). Inputs / γ from fixed splitmix64 seeds.
+Fingerprints = FNV-1a 64 over the Q16 probabilities, the int32 RMSNorm output, the `exp` table, and a
+combined digest of (softmax ‖ rmsnorm ‖ argmax).
+
+## Artifacts (`docs/evidence/`)
+
+`canon_ops.rs` (CPU ref), `canon_ops_metal.swift` (Metal shaders), `canon_ops_cuda.cu` (CUDA). GPU builds
+run softmax and RMSNorm on-device (single-thread kernels using `ulong`/`long` for the reductions and
+`isqrt`); the host computes argmax and the FNV folds.
+
+## Results
+
+| backend | hardware | ISA / arch | EXP_LUT fnv | COMBINED fnv |
+|---|---|---|---|---|
+| CPU | Mac | aarch64 | `c4ddbbc186fe4e82` | `4bf581ead4d57139` |
+| CPU | RTX host (WSL2) | x86_64 | `c4ddbbc186fe4e82` | `4bf581ead4d57139` |
+| Apple Metal GPU | M1 Max | Apple GPU | `c4ddbbc186fe4e82` | `4bf581ead4d57139` |
+| NVIDIA CUDA GPU | RTX 4060 Ti | Ada `sm_89` | `c4ddbbc186fe4e82` | `4bf581ead4d57139` |
+
+Per-op (identical on all four): softmax `4344a6ed2626237e`, rmsnorm `4465b751f2412255`, argmax index `495`.
+RMSNorm `inv_q16 = 113` (correctly ≈ `2^16/√mean`); softmax probabilities are non-uniform — the ops are
+genuinely exercised.
+
+## Reading
+
+- The two ops that would normally re-introduce fp via a transcendental (`exp` in softmax, `rsqrt` in
+  RMSNorm) are backend-independent when done with a **pinned integer table** (`exp`) and **integer Newton**
+  (`rsqrt`). Metal's `long`/`ulong` and CUDA's `long long` both give the identical integer result as the CPU.
+- Op coverage is now complete: GEMM (inc2) + bias/requant/LUT (inc3) + softmax/RMSNorm/argmax (inc4a) =
+  every primitive a dense-transformer forward needs, each proven byte-identical on CPU×2 ISAs + 2 GPU
+  vendors.
+
+## Honest scope / what remains (increment 4b)
+
+- These are the **op primitives**, not a whole model. Increment 4b composes them into the full dense
+  Qwen2.5-0.5B forward with the **real quantized weights** (24 layers, RoPE, GQA attention, SwiGLU, tied
+  LM head) and validates that (a) it produces sensible tokens and (b) the token `vector_commitment` is
+  identical across CPU/Metal/CUDA. That integration — plus choosing a quantization that preserves output
+  quality — is a substantially larger effort than these primitives.
+- Single-thread reductions here; parallel-reduction/tensor-core variants are a hardening follow-up (integer
+  associativity already covers them — increment 1).
+- The `exp` table and `rsqrt` here are demonstrator fixed-point approximations; a production spec pins the
+  exact tables / iteration counts as part of the model artifact.
+- No Turing (`sm_75`) run; by the theorem it must also yield `4bf581ead4d57139` (user HW step).
diff --git a/docs/evidence/canonical-int-quantizer-2026-07-19.md b/docs/evidence/canonical-int-quantizer-2026-07-19.md
new file mode 100644
index 0000000000000000000000000000000000000000..a3c10d0773f18301a05a482e9baf27418444f134
--- /dev/null
+++ b/docs/evidence/canonical-int-quantizer-2026-07-19.md
@@ -0,0 +1,68 @@
+# Evidence — inc4b-1 offline canonical quantizer core (2026-07-19)
+
+First cut of the offline quantizer for [inc4b](../canonical-integer-inc4b-fullmodel-design.md) §7 (4b-1).
+Produces the per-tensor int8 weights + **pinned fixed-point per-output-channel scale** that the integer
+runtime consumes. Floating point is used **offline only** (this tool); the emitted `.canon` bytes are the
+canonical artifact every backend consumes identically.
+
+## What it does (`docs/evidence/canon_quant.rs`)
+
+- **Per-output-channel symmetric int8 quantization**, round-half-away-from-zero (deterministic).
+- Each channel's dequant scale `amax/127` is pinned as a **gemmlowp-style fixed point** `(M0: i32, shift: i32)`
+  with `scale ≈ M0·2^(shift-31)`, `M0 ∈ [2^30, 2^31)`.
+- Minimal `.canon` v0 container (`magic ‖ out_ch ‖ in_ch ‖ int8 weights ‖ per-channel (M0,shift)`), with a
+  write/read round-trip.
+- Self-test on a synthetic `[896, 896]` (Qwen-0.5B proj-sized) weight matrix — no model download needed.
+
+## Results (identical on aarch64 Mac and x86_64 RTX host)
+
+```
+tensor              = [896, 896] int8, per-channel fixed-point scale
+round-trip (dequant): max_abs_err=3.933e-4  rms_rel_err=0.0054
+fixed-point scale rel err (max) = 3.06e-10
+.canon bytes        = 810000   fnv=a9be59709b4253fe
+.canon round-trip   = OK (weights+scales identical)
+sample ch0: M0=1686124657 shift=-10 scale=7.667607e-4
+```
+
+## Reading
+
+- int8 per-channel quantization round-trips at **0.54% RMS** (normal for symmetric int8) — a quality figure,
+  separate from determinism.
+- The **fixed-point scale reconstructs the true `amax/127` to 3e-10 relative** — the 31-bit `M0` pins the
+  scale essentially exactly, so no fp scale is needed at runtime.
+- The `.canon` artifact is **byte-identical across aarch64 and x86_64** (`a9be59709b4253fe`) — even the
+  offline fp quantization reproduced across ISAs here, so artifact builds are reproducible (the artifact is
+  still meant to be published once and hash-pinned regardless).
+
+## Real-model run (full quantizer, `docs/evidence/canon_quant_full.py`)
+
+With user permission, the **bf16 original** `model.safetensors` was downloaded from
+`huggingface.co/Qwen/Qwen2.5-0.5B-Instruct` (988,097,824 bytes, sha256 `fdf756fa…288fb7fe`) onto the RTX
+box, and the full quantizer (safetensors parser + per-channel int8 + fixed-point scale, numpy) produced the
+complete `.canon` v1 artifact:
+
+```
+tensors: 290           # token_embd + 24×(2 norms + q/k/v/o + q/k/v bias + gate/up/down) + final norm; LM head tied
+params: 494,032,768
+.canon: 497,937,154 bytes  blake2b16=bdb64817060deaf1898ef8918a4e181a
+169 2D tensors int8 per-channel;  121 1D tensors (norms/biases) as fixed-point int32
+worst per-tensor rms (2D): 0.0149  model.layers.16.mlp.down_proj  (down_proj / v_proj are the known-hard ones)
+```
+
+- **Artifact is deterministic**: a byte-identical re-run reproduces `blake2b16=bdb64817…`.
+- Tensor accounting matches the confirmed arch exactly (290 = 1 + 24·12 + 1), so the parse is complete.
+- Worst per-tensor quantization RMS ~1.5% (down_proj/v_proj); most tensors far lower. That is a **quality**
+  figure (per-tensor symmetric int8); if 4b-5 shows token-quality loss, per-group scales fix these outliers.
+- The 498 MB `.canon` lives on the RTX box (`/root/models/qwen05.canon`); it is a build output, hash-pinned
+  by `bdb64817…`, not committed to the repo.
+
+## Honest scope / what remains
+
+- inc4b-1 is **done**: a deterministic W8A8 `.canon` artifact from the real bf16 weights. Next (4b-2) the
+  integer runtime consumes this artifact for an attention block; RoPE fixed-point cos/sin tables + SiLU/exp
+  LUTs (integer generators proven in inc3/inc4a) are generated there (they are model-independent constants).
+- Activation quantization (dynamic per-token int8 with fixed-point scale) and the exact bias/norm consumption
+  are runtime concerns (4b-2+), not part of this offline tool.
+- The offline fp quantizer reproduced its artifact across aarch64/x86_64 on the *synthetic* self-test; the
+  real-model artifact hash `bdb64817…` is the pinned identity regardless (publish-once).
diff --git a/docs/evidence/canonical-int-qwen36-bench-2026-07-20.md b/docs/evidence/canonical-int-qwen36-bench-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..716fdc0e9172e358a77a5274e109845198c1f15e
--- /dev/null
+++ b/docs/evidence/canonical-int-qwen36-bench-2026-07-20.md
@@ -0,0 +1,34 @@
+# Evidence — QI35-9: 性能測定 — 純粋 Qwen3.6 vs receipt システム (2026-07-20)
+
+同一 Mac Studio(M1 Max 32GB)・同一本番 blob(23.9GB Q4_K_M)・同一 prompt
+"The capital of France is"(5 tokens)+ 32 token 生成で、fp/整数 × receipt 有無の 4 構成を実測。
+
+| # | 構成 | 生成速度 | 応答全体の wall | 内訳 |
+|---|---|---|---|---|
+| 1 | **fp Metal 素**(llama-bench, build-palw)| **decode 52.0 ± 0.5 tok/s**(tg32)、prefill 105.6 tok/s(pp5)| —(生成のみ)| GPU 実行 |
+| 2 | **fp Metal + receipt**(palw-metal-receipt, n=32)| 生成自体は #1 相当 | **242s** | manifest(SHA-256 24GB ×前後 2 回)+ observer(Metal kernel trace)+ 署名/bundle/state-db が支配 |
+| 3 | **整数 CPU 素**(qi35_model, 8 threads)| **1.66 tok/s**(37 forward / 22.4s ≈ 0.61s/token)| 22.4s | CPU のみ(Metal 版は未実装 = QI35-5)|
+| 4 | **整数 CPU + receipt**(palw-integer-receipt, n=32)| エンジン 24.3s | **50s** | + blake2b256 24GB ハッシュ ~26s、ML-DSA-87 署名+bundle+state-db は合計 <1s |
+
+## 読み取り(正直に)
+
+- **生成エンジン単体**: fp Metal が整数 CPU の **~31×** 速い。整数側は GPU 未移植(QI35-5)のためで、
+  整数の原理的限界ではない(演算量は同じ A3B)。
+- **receipt システムのオーバーヘッド**:
+  - fp 版: +~240s/発行。SHA-256 二重ハッシュ(実行前後の manifest 一致確認)と kernel trace が本体。
+  - 整数版: +~28s/発行で、**ほぼ全てが blake2b 24GB ハッシュ**。署名(ML-DSA-87)・XChaCha bundle・
+    sqlite 書き込みはミリ秒〜1s 未満。ハッシュはファイル不変なら**キャッシュ可能**(mtime+size キーで
+    ~2s 台まで短縮できる — 未実装の最適化)。
+- **発行込みの応答時間**では、整数フロー(50s)が fp フロー(242s)の **~4.8× 速い**。整数 class の
+  evidence が「再実行で完全再現」という性質そのもので、実行時の trace 計装が不要なため。
+- チャット常駐(qi35_chat.sh)ではモデルハッシュはセッション 1 回なので、2 問目以降の receipt 付き
+  応答は「エンジン時間 + <1s」になる。
+
+## 測定条件の注記
+
+- fp 素は llama-bench(r=2)。llama-cli(build-palw)は `-no-cnv` 指定でも対話ループに入る挙動があり
+  計測に不適(2 回ログ暴走)— ベンチは llama-bench を正とする。
+- #2/#4 の wall はコマンド起動〜終了(モデルロード込み)。page cache は直前ランで温まった状態。
+- RTX box(WSL2 x86_64, RAM 21GB)の整数エンジンは同一ジョブ 8 token で 24.6s(Mac 10.0s)—
+  24GB blob が RAM を超え mmap ページングになるため。機能・commitment は完全一致
+  ([v3-pair evidence](canonical-int-qwen36-v3-pair-2026-07-20.md))。
diff --git a/docs/evidence/canonical-int-qwen36-chat-receipt-2026-07-20.md b/docs/evidence/canonical-int-qwen36-chat-receipt-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..bba28df9b89acc985c0aacb0e7cc609fa7a5a889
--- /dev/null
+++ b/docs/evidence/canonical-int-qwen36-chat-receipt-2026-07-20.md
@@ -0,0 +1,76 @@
+# Evidence — QI35-6/7: 整数エンジンの対話化 + canonical 整数 receipt 自家発行 (2026-07-20)
+
+本番 Qwen3.6-35B の **canonical 整数エンジン**を(1)Claude 風の対話 UI にし、(2)各応答で
+**backend 非依存の canonical_integer_v0 receipt を自家発行**、(3)独立再実行で検証できるようにした記録。
+
+## 構成
+
+- **エンジン** `qi35_model`(docs/evidence/qi35_model.rs、依存ゼロ Rust): `--serve` 常駐モードを追加。
+  stdin から prompt token id 列を受け、状態(KV/DeltaNet/conv)をリセット→整数 greedy 生成→
+  `GEN <ids>` / `RCPT <json>` / `DONE` を stdout に出す。EOS(`<|im_end|>`=248046)で停止。
+  純 Rust **BLAKE2b**(keyed/unkeyed)を実装 — Python `hashlib.blake2b` と**バイト一致を検証**
+  (unkeyed `8ae72774…`、keyed も一致)。
+- **チャット** `qi35_chat.py` + `qi35_chat.sh`: tokenizer.json(base-meta 同梱)+ Qwen3.6 chat
+  テンプレート(`<|im_start|>role\n…<|im_end|>`)で文↔token 変換、履歴付き REPL。エンジンを
+  serve 子プロセスとして起動し、応答ごとに receipt + opening を保存。
+- **検証** `qi35_verify.py`: receipt + opening(prompt/output ids)を受け、MAC・prompt_commitment・
+  output_commitment を再計算し、`--rerun` で**整数エンジンを別途再実行して output_commitment を
+  独立再現**。
+
+## receipt スキーマ(`palw.canonical-integer-receipt/v0`)
+
+keyed-BLAKE2b-256 MAC(監査鍵)で以下を束縛。**秘密(鍵・生 prompt)は receipt に一切含めない**:
+- `network_id`(= blake2b(dom‖label))、`timestamp_millis`、`backend`(rust-cpu-aarch64 等)
+- `model_blake2b256`(本番 GGUF 全体 = `fabdc6dc…5326c`)/ `engine_blake2b256` / `tables_blake2b256`
+- `ruleset_id=qi35-int-v1`、`prompt_tokens`/`output_tokens`/`eos_reached`
+- `prompt_commitment` = blake2b(dom‖network‖prompt_ids)
+- **`output_commitment` = blake2b(dom‖network‖prompt_commitment‖output_ids)** ← **backend 非依存の核心**
+- `signer_key_id` = keyed_blake2b(key, dom)(鍵を露出せず署名主体を識別)、`mac`
+
+## 実機ラン(Mac Studio M1 Max、CPU)
+
+一問一答(`qi35_chat.sh "What is the capital of France? Answer in one sentence."`):
+
+```
+[engine] hashing model (blake2b, ~once) model_blake2b256=fabdc6dc…5326c (29.2s)
+Q: What is the capital of France? Answer in one sentence.
+A: <think> The user is asking for the capital of France, which is Paris… </think>
+   The capital of France is Paris.
+   [receipt canonical_integer_v0  out_commit=328fe5c4d123f558…  MAC=OK  46.92s 35tok]
+```
+
+- **正答・流暢**。Qwen3.6 の `<think>` 推論ブロックも整数経路で正しく生成(必要なら system prompt で抑制可)。
+- receipt 自家発行 + MAC 検証 OK。model ハッシュはセッション 1 回(29s、以後は常駐で無料)。
+- 応答内で **integer engine が生成 = fp Metal observer は不使用**。fp receipt(trace_evidence=metal_kernel)
+  との本質的な違い: fp receipt は Metal カーネル launch 列に束縛され他 HW で再現不能。本 receipt の
+  `output_commitment` は**整数決定性により任意 HW で再現可能** → `qi35_verify.py --rerun` が独立に一致確認できる。
+
+## 検証の実機確認 — 独立再実行で output_commitment 再現
+
+同一 (model, prompt=`[760,6511,314,9338,369]`) を**独立に 2 回**、しかも**スレッド数を変えて**
+(run A: 8 threads / run B: 4 threads)整数エンジンで走らせ、receipt の `output_commitment` を比較:
+
+```
+A(8t) = d11d99254cf145b1a6f1a00faef4c09989772ef9240ee601584348754a65d0e6
+B(4t) = d11d99254cf145b1a6f1a00faef4c09989772ef9240ee601584348754a65d0e6
+COMMITMENT_MATCH ✅
+```
+
+並列度に依らず commitment がビット一致 = **検証者が別ラン(別 HW でも)で receipt を独立再現できる**
+ことの直接証拠。`qi35_verify.py --rerun` はこの再現一致 + MAC + prompt/output commitment を自動判定する。
+(prompt_commitment/output_commitment/MAC は Python `hashlib.blake2b` 側の独立実装でも一致を確認。)
+
+## backend 非依存性の担保(既存 evidence の再掲)
+
+整数 forward は結合律で reduction 順序・並列度・ISA 非依存(G2/G3 で実証: threads=4/8 で FNV 一致、
+CPU x86/aarch64 一致)。したがって `output_commitment` は「同じ (model, prompt) を同じ canonical
+エンジンで走らせれば、Mac/x86/CUDA のどれでも同一」。これが fp receipt に対する本 class の優位点。
+
+## 正直な限界
+
+- 本 receipt は**独立した canonical class**であり、既存 `palw-metal-receipt` の ML-DSA-87 署名 +
+  暗号化 bundle + state-db + network anchor には**まだ統合していない**(MAC は監査鍵ベースの
+  keyed-BLAKE2b で、ネットワーク束縛や worker credential bond はない)。mint 適格性は fp 版同様 false。
+- 会話は毎ターン全文脈を prefill し直す(状態リセット)方式。context が伸びると 1 ターンが伸びる
+  (CPU で ~0.85s/token)。KV 持ち越し高速化と Metal offload(QI35-5)は未実施。
+- `<think>` により token 数が増える。concise 運用は system prompt(`/no_think` 等)で調整。
diff --git a/docs/evidence/canonical-int-qwen36-fullmodel-g3-2026-07-20.md b/docs/evidence/canonical-int-qwen36-fullmodel-g3-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..342fd707a921f59a5883f4c3b29ddec70518efe9
--- /dev/null
+++ b/docs/evidence/canonical-int-qwen36-fullmodel-g3-2026-07-20.md
@@ -0,0 +1,42 @@
+# Evidence — QI35 G3(部分): Qwen3.6-35B full-model 整数 forward 実機ラン (2026-07-20)
+
+[QI35 設計](../canonical-integer-qwen36-design.md) ゲート G3 の初回実測。エンジンは
+`qi35_model.rs`(本ディレクトリ、依存ゼロ: `rustc -O --edition 2021`、mmap 直読 + std::thread 並列)。
+重みは**本番 blob そのもの**(変換なし)、LUT/RoPE は pinned 成果物
+`qi35_tables.bin`(4,849,688 bytes、blake2b16 `b0a8e021b35aaceec3b08eeb31064cd2`、
+生成器 `qi35_export_tables.py`)。
+
+## 実行(Mac Studio M1 Max 32GB、CPU のみ)
+
+40 層(DeltaNet 30 + attention 10)+ MoE top-8 + shared + LM head(Q6_K 248,320 行)+
+整数 argmax。KV cache / DeltaNet 状態 / conv 状態を持ち越す逐次 decode。
+
+| prompt (tokens) | fp CPU greedy (llama.cpp) | 整数 canonical | 一致 |
+|---|---|---|---|
+| "Hello, world" `[9419,11,1814]` | `[0,198,40,2688,264,491,1156,314]`("!\nI'm a new user of")| `[0,198,40,2688,264,3061,22839,13]`("!\nI'm a software engineer.")| **先頭 5/8**、6 個目("a␣new" vs "a␣software")の低マージン手で分岐 |
+| "The capital of France is" `[760,6511,314,9338,369]` | `[11751,11,264,3177,34756,364,1141,25438]` | 同一列(**" Paris, a city renowned for its iconic"**)| **8/8 完全一致** |
+
+合計(初回測定): **13/16 一致**、分岐は 1 箇所の低マージン手のみ。
+
+- **決定性**: 同 prompt を threads=4 / threads=8 で実行 → **ids FNV 完全一致**(`ff03bf7c9a5d7593`)。
+  整数結合律により並列度がビットに影響しない(設計どおり)。
+- **速度**: prefill+decode 11 forward ≈ 9.4–10.0s → **~0.85s/token(CPU 8 threads)**。
+  0.5B 時代の「1 問数分」から、35B で桁違いに実用的。GPU 化(QI35-5)前の CPU 値。
+
+## 実装で確定した追加意味論(設計書反映)
+
+- **正規化シフト(pinned)**: norm 系の積(h·inv·γ など)は **RNE >>30 で ≤2^52 に正規化してから
+  aq** する(スケール補正 74→44 等)。理由: 生の積は 2^76–2^92 に達し、`amax·2^60` が **i128 を
+  超えて Rust release で無音 wrap** する(Python bigint 参照では顕在化しない罠)。G2 全チェックを
+  この意味論で再実行し、**誤差プロファイルは変化なし**(worst 一覧が同一)を確認済み。
+- `sfrom` はオーバーフロー安全形 `(a/L)·c + ((a%L)·c)/L`(exact 恒等)で実装。
+- LM head argmax は (acc, e) ペアの**厳密比較**(bitlen+指数、同桁は整列比較)で fp 経由なし。
+
+## 正直な限界
+
+- G3 は 2 prompt × 8 token の初回測定。**分岐後の比較は無意味**(文脈が変わる)なので、指標は
+  「最初の分岐までの一致長」。統計的な一致率測定(多 prompt)は未実施。
+- fp 側との分岐そのものは canonical class の設計上の性質(W4+A24 の別モデル)。品質は生成文の
+  流暢さ・事実性で判断する段階で、perplexity 定量は未実施。
+- 現状 CPU のみ。Metal offload(QI35-5)・CUDA 一致(G5)は未実施。
+- chat template / tokenizer 統合(実際の Q&A UI)は未接続(llama-tokenize で手動 encode)。
diff --git a/docs/evidence/canonical-int-qwen36-layer-g2-2026-07-20.md b/docs/evidence/canonical-int-qwen36-layer-g2-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..aaa19d259eba3634896ee61b64786fde80983f93
--- /dev/null
+++ b/docs/evidence/canonical-int-qwen36-layer-g2-2026-07-20.md
@@ -0,0 +1,64 @@
+# Evidence — QI35 G2: Qwen3.6-35B 実重み layer 単位の整数/fp 照合 (2026-07-20)
+
+[QI35 設計](../canonical-integer-qwen36-design.md) のゲート **G2** を実施した記録。
+対象は**本番 blob そのもの**(`Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf`、23,938,321,728 bytes)。
+0.5B デモは以後使用しない(ユーザ指示)。
+
+## 手順(再現可能)
+
+1. `palw_fp_dump.cpp`(本ディレクトリ)を vendored llama.cpp(`build-cpu`, Metal OFF)に対して
+   コンパイルし、prompt `"Hello, world"`(tokens `[9419, 11, 1814]`)で prefill(s0)+ greedy
+   1 token(s1: token 0)を実行。layer 0(DeltaNet)/ layer 3(attention)/ MoE / l_out-2 の
+   全中間テンソルを**全要素** fp32 でダンプ(202 ファイル、15MB)。
+2. `qi35_int_ref.py`(本ディレクトリ)= exact 整数リファレンス。GGUF を直接 mmap し、
+   Q4_K/Q6_K を **fp16 スケールの exact (mant,e) 分解**で整数消費(再量子化なし・丸め追加なし)。
+   設計書の整数意味論(Q60 スケール、per-token A24、DeltaNet 内部 Q16/Q20/Q24、LUT 群)で
+   layer 0(prefill 3 token + 状態持ち越し decode 1 token)と layer 3(fp l_out-2 入力の単層テスト
+   + KV cache 持ち越し decode)を実行し、fp32 ダンプと全チェックポイント照合。
+
+## 結果(relmax = max|Δ|/max|ref|、全 77 チェックポイント)
+
+**layer 出力・状態(判定対象)— 全て 5% 以内で PASS**:
+
+| checkpoint | prefill (s0) | decode (s1) |
+|---|---|---|
+| DeltaNet state(128×128×32)| relmax 1.45e-2 / rmse **1.1e-4** | 1.51e-2 / **8.9e-5** |
+| final_output(gated norm 後)| 6.7e-3 | **8.9e-4** |
+| linear_attn_out | 1.7e-2 | 1.5e-2 |
+| l_out_0(層出力)| **1.1e-2** | — |
+| MoE top-8 選択(layer 0/3, s0/s1)| **全 4 ケース exact 一致** | 同左 |
+| ffn_out_0 / ffn_out_3 | 1.9e-2 / 5.0e-3 | 3.0e-2 / 1.9e-2 |
+| attention 経路(Qcur/Kcur roped, pregate, gated, output)| ≤4.6e-2 | ≤2.4e-2 |
+| l_out_3(層出力)| **3.5e-3** | **1.6e-3** |
+
+全数値は `qi35_int_ref.py` 実行ログ参照。embedding は exact 分解のため fp32 丸め誤差のみ(2e-7)。
+
+**例外(記録)**: `s0_moe_probs_0` relmax 5.8e-2(rmse 6.7e-3)のみ 5% 超。原因は上流(layer-0
+チェーン)の A24 量子化ノイズが logit 差 → exp で増幅されるため(**単層テストの layer-3 router は
+1.6e-2 で通過**、logits は 0.9e-2)。top-8 選択・正規化重み・ffn_out には影響していない。
+
+## 実装中に確定した設計定数(設計書に反映済み)
+
+- **eps 整数化**: rms_norm_eps 1e-6 → `EPS_Q40=1,099,512`(2^40)/ `EPS_Q48=281,474,977`(2^48)。
+  スケール可変テンソルは per-token に `eps_int = EPS_Q40·U²>>40`(U=2^60/scale)。
+  ※ 初期実装で 1000× 小さい定数を置くバグがあり、減衰 head(o≈2e-5)が eps-floor 支配で
+  29× ずれた — **eps は fidelity の一級市民**(4b-2a の RMSNorm 教訓の再演)。
+- **γ(decay)LUT**: exp(g), g∈[−16,0]、**1/2048 刻み・32769 entry・Q30**(実測 g は absmean 8.8)。
+- **exp LUT**: [0,8) **1/2048 刻み・16384 entry・Q20**(0.5B の 2048×1/512 から拡張 — 35B の
+  router logit 差は最大 ~7.2 で旧定義域 [0,4) を超える)。
+- **softplus LUT**: [−16,16) 1/512・Q16、x>20 は恒等(ggml 準拠)。
+- **KV cache / DeltaNet conv・v**: per-token スケールではなく**絶対固定小数点 Q16**で保存
+  (逐次 decode ≡ prefill のビット一致が自明になる。範囲は実測 ±35)。
+- **状態 S**: Q24 / i64(実測 |S|≤10 → 積和が i64 に収まる。GPU 化に i128 不要)。
+- q/k(L2 norm 後)Q20、β/softplus Q16、1/√128 は Q30 定数、attention scale 1/16 は exact。
+- fused GDN の head 対応: v-head h → k-head **h % 16**(タイル型、`ops.cpp:10749-10750`)。
+- fp グラフの cb 名 `Kcur` は射影直後と RoPE 後で重複 — ダンプ照合は 2 個目(`__1`)を使うこと。
+
+## 正直な限界
+
+- 照合は 1 prompt × (3+1) token × layer 0/3 のみ。全 40 層 greedy token 一致率は G3(未実施)。
+- 単層誤差 1–3% は W4(Q4_K 固有)+ A24 + LUT の合成ノイズで、これが canonical class の
+  fp 追跡限界。低マージン手での token 分岐は G3 で定量化する。
+- Python リファレンスは遅い(全照合 ~3 分)。性能は QI35-4(Rust)/QI35-5(Metal)の担当。
+- LUT 生成はオフライン fp(pin 後は決定的)。Rust/Metal 移植時は**テーブルのバイト列を成果物として
+  固定**し、生成方法ではなくテーブル自体を配布する。
diff --git a/docs/evidence/canonical-int-qwen36-metal-v1-2026-07-20.md b/docs/evidence/canonical-int-qwen36-metal-v1-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..cb7dba6bbe764e47fa3ce594f73887051eb738be
--- /dev/null
+++ b/docs/evidence/canonical-int-qwen36-metal-v1-2026-07-20.md
@@ -0,0 +1,192 @@
+# Evidence — QI35-5 v1: 整数エンジン Metal offload(bit-exact)+ 秒単位 receipt (2026-07-20)
+
+## 構成(CUDA-mirror、設計どおり)
+
+- `qi35_metal_shim.m`(本ディレクトリ): MSL カーネル `gemm_q4k`/`gemm_q6k` — Q4_K/Q6_K ブロックを
+  **カーネル内で整数 fp16 ビット分解**し、superblock 部分和を**指数整列つき exact 128-bit (lo,hi)
+  加算**で畳む(整数結合律 → スレッド順序がビットに影響しない)。重みは **mmap 領域への
+  per-tensor no-copy MTLBuffer**(24GB 単一バッファは maxBufferLength=20.1GB 超のため、ページ境界
+  切り下げ+バッファ内オフセット+キャッシュ)。x/out はバッファプール再利用。
+- Rust 側 `gemm_batch`: 依存のない GEMM 群(qkv+gate / q+k+v / expert gate+up×8+shared /
+  down×8+shared)を**1 command buffer に一括エンコード**して commit。rows<256 は CPU のまま。
+  ホストの整数グルー(aq/norm/再帰/softmax)は CPU — 意味論は完全不変。
+- 追加高速化: prefill 中の LM head(508M MAC)スキップ(最終位置のみ計算)、MoE ルーター/shexp
+  ゲート/最終 norm 重みの起動時キャッシュ(毎 forward の 52 万要素 F32 変換を排除)、DeltaNet
+  再帰の head 並列化。
+
+## bit-exactness(canonical class の生命線)
+
+| 検証 | 結果 |
+|---|---|
+| カーネル selftest(Q4_K/Q6_K×5 tensor、16-GEMM バッチ、row0≠0、k=512/2048/4096)| **全行一致** |
+| full 8-token: tokens / FNV / route_root / kv_root / state_root | **CPU と全一致** |
+| full 32-token: FNV `8cd22345b5a14c5a` | **CPU と一致** |
+| Metal エンジンで発行した v3 receipt の output_commitment | 既存 cross-vendor 値 `e0697cf9…e104` と**同一** |
+
+途中で踏んだバグ 2 件(記録): (a) MSL 予約語 `half` を変数名に使用 → コンパイル失敗、
+(b) スレッドローカル配列 `A[8]` が k=4096(`ssm_out`/`attn_output`、nsb=16)で**配列外書き込み**
+→ 出力破壊。selftest が k=2048 のみだったため見逃し — 「全 k 形状を selftest に含める」を教訓化。
+
+## 速度(Mac Studio M1 Max、5 prompt + 32 decode)
+
+| 構成 | 時間 | tok/s |
+|---|---|---|
+| 整数 CPU(改善込み)| 0.61s/token | 1.66 |
+| **整数 Metal v1** | **0.276s/token** | **3.6**(2.2×)|
+| fp Metal(参考)| — | 52.0 |
+
+プロファイル実測: **2609 commit/13fwd(~200/token)× ~1ms = GPU 往復が 63%**。GPU 演算自体は
+数 ms/token。試して**棄却**した策: commit の busy-wait(コア競合で悪化)、proj_finish/aq の
+マイクロ並列化(thread spawn コスト > 利得)。
+
+## 秒単位 receipt(達成)
+
+- `palw-integer-receipt` に **mtime+size キーのモデルハッシュキャッシュ**(/tmp/qi35-hash-cache.txt)
+  を追加、`QI35_ENGINE_ARGS="--metal"` でエンジン引数を配線(verify --rerun 側も同様)。
+- 実測: 初回発行 29s(cold hash)→ **2 回目以降 6s**(Metal 生成 3.4s + 署名/bundle/db + tokenize)。
+  検証 --rerun も全 PASS。チャット常駐(`QI35_METAL=1 qi35_chat.sh`)は生成時間+1s 未満で receipt 付与。
+
+## 52 tok/s 級への残り(v2 ロードマップ、正直に)
+
+現況 3.6 tok/s の支配項は **dispatch 往復 ~200 回/token**。52 tok/s(19ms/token)には:
+1. **層単位の単一 command buffer 化** — グルー(aq/rms/conv/silu/再帰/softmax)を Metal カーネル化し、
+   1 token = 数 commit に削減(親設計 §8 の full-device 路線。LUT/isqrt は整数なので移植は素直)。
+2. 期待値: GPU 演算 5-10ms + commit ~5 回 ×1ms + 残 CPU(router/argmax)→ **20-40 tok/s 圏**。
+   fp 並(52)には attention/KV も on-device 化が必要。
+3. 併走オプション: RTX 側 CUDA カーネル(同じ 128-bit 整列加算、i128 → 2-word)— cross-vendor の
+   まま両バックエンド高速化。
+
+## 再現
+
+```
+clang -O2 -fobjc-arc -shared qi35_metal_shim.m qi35_metal_moe.m qi35_metal_dn.m \
+  -framework Metal -framework Foundation \
+  -install_name @rpath/libqi35metal.dylib -o libqi35metal.dylib
+rustc -O --edition 2021 qi35_model.rs -L <dir> -l qi35metal -C link-arg=-Wl,-rpath,<dir> -o qi35_model
+./qi35_model <gguf> qi35_tables.bin --ids ... --metal          # bit-exact GPU 実行 (v1)
+./qi35_model <gguf> qi35_tables.bin --ids ... --metal-v3       # MoE+DeltaNet on-device (Phase A+B)
+QI35_SHADOW=1 ... --metal-v3                                   # 層単位 CPU/GPU 突合(pipe に head 禁止)
+QI35_SELFTEST=1 ./qi35_model <gguf> qi35_tables.bin            # カーネル CPU/GPU 突合
+QI35_ENGINE_ARGS="--metal" palw-integer-receipt ...            # 秒単位 receipt
+```
+
+## 追記 — v2 試行の実測結果 (同日深夜)
+
+**常駐スレッドプール**(spawn レス並列)を実装し、グルー(proj_finish/aq/変換)の並列化を試行:
+- 細粒度プール化(~300 呼び出し/token × 7 wake)は **Metal 完了待ちとスケジューラ競合**し
+  GPU wall を 2.53s→11.2s に悪化させた(M1 の P コア争奪)。小 n 直列ガードでも 4.55s止まり。
+- **確定構成**: プールは粗粒度サイトのみ(DeltaNet 再帰 head 並列 / CPU GEMM / router)、
+  細粒度グルーは直列。最終 **0.268s/token = 3.7 tok/s**(bit-exact 維持、FNV `8cd22345…`)。
+
+**結論(実測に基づく)**: 現アーキテクチャ(GEMM=GPU/グルー=CPU)は **~200 commit/token ×
+~0.8-1ms の dispatch 往復が構造的下限**で、頭打ちは ~4 tok/s。20-40 tok/s には
+**グルーの完全 on-device 化**(aq/rms の reduction カーネル + Q60 スケール代数の (m0,e) 正規化
+2-word 実装 + 層単位 1-2 commit)が必須 — 親設計 §8 の full-device 路線そのもので、
+次セッション規模の独立した実装作業。CPU 側マイクロ最適化はこの SoC では逆効果と実証済み。
+
+## 追記 2 — v3 Phase A(MoE full-device)実装状況 (同日)
+
+- `qi35_metal_moe.m`: **MoE 全段を 1 command buffer に on-device 化**(I128 2-word 演算・binary
+  128-bit floor 除算・Q60 スケール代数・router I128 dot・決定的 top-8・silu·up・加重和、~20 dispatch)。
+  `--metal-v3` + `QI35_SHADOW=1` で **層単位 CPU/GPU 突合パス実装済み**、単発入力で全層一致を確認
+  (発見済みバグ 2 件修正: k_shgate の 128-bit 積引数順、shared expert の us スロット)。
+- **未解決 2 件(v3 続行の起点)**: (a) 実チェーン実行で tokens/FNV は一致するが route/kv/state root
+  が CPU 真値と不一致 — 未検出の入力依存分岐あり。`QI35_SHADOW=1` を実プロンプトで回し最初の
+  分岐層を特定するのが次の一手。**production は --metal(v1)のまま**。(b) moe_gpu_wall
+  292ms/token — `k_topk` の thread-local 256 要素配列がデバイスメモリにスピル。threadgroup
+  memory 化(es[256] を shared に、max/選択は barrier 後 thread0)で解消見込み。
+- 教訓: GPU 単一スレッドカーネル + thread-local 大配列は数 ms 級の罠;shadow 比較は**実プロンプト
+  の実チェーンで**回すこと(単発入力の全層 OK は十分条件でない)。
+
+## 追記 3 — v3 Phase A 完成: MoE full-device が bit-exact 成立 (2026-07-20 深夜 2)
+
+- **バグ確定と修正**: 前回の「実チェーンで roots 不一致」の真因は 2 つ:
+  (1) **検証ハーネス側** — shadow 実行を `| head -N` に繋いだため SIGPIPE で layer 30 前に
+  エンジンが死んでおり「全層 OK」は偽陽性だった(教訓: 検証パイプに head を挟まない)。
+  (2) **本物のバグ** — k_topk の重み正規化を 2 段(w30→wsum 再正規化)で実装していたが、
+  CPU 意味論は **1 段**(`wn = fdiv(es·2^30 + dsel/2, dsel)`)。half 境界でのみ 1 ULP ずれ、
+  layer 30 の wn[0] が 1 差 → smax 経由で全 ratio 汚染 → tot 1 要素 1 差。段階別ダンプ
+  (dq/ds/wn/rat/smax レジスタ読出し)で機械的に特定。
+- **修正後**: 実プロンプト 8-token の shadow **520/520 全通過**、FNV・route/kv/state root
+  すべて CPU 真値と一致。**MoE 全段 on-device が正式に bit-exact**。
+- **速度改善**: k_topk/k_shgate の threadgroup 化 + **proj_finish チェーンの単一カーネル融合**
+  (colsq→cmax→rescale→amax→aq を threadgroup barrier で 1 dispatch 化、k_finish/k_finraw)
+  + concurrent エンコーダ + memoryBarrier フェーズ化(~26→~17 dispatch、~10 フェーズ)。
+  moe_gpu 292→**151ms/token**、8-token total 4.9→**4.0s**。
+- **計測結論(Phase D の根拠)**: per-CB commit+wait ≈ 1.5-2.5ms(高分散)が現在の床。
+  fp llama.cpp が同 GPU で単一 CB/token(~2500 op エンコード)により 52 tok/s を出している事実
+  から、CB 内エンコード op のコストは ~10µs 級 → **全 token 単一 CB(Phase B/C/D: DeltaNet・
+  attention・残差/rms を on-device 化し hv を GPU 常駐)で 30-40 tok/s は到達可能**。
+  必要部品(I128 演算・fused finish・reduction・LUT)は Phase A で全て実証済み。
+
+## 追記 4 — v3 Phase B 完成: DeltaNet full-device が bit-exact 成立 (2026-07-20 深夜 3)
+
+- `qi35_metal_dn.m`(新規): **DeltaNet 全段を 1 command buffer / 13 dispatch に on-device 化**。
+  4 GEMM(qkv/gate/beta/alpha)→ fused finish×4 → per-head scalars(sig/softplus/gamma LUT)
+  + conv(to_fix→4-tap Q30→silu→ring shift、channel-local)→ L2 norm(u64 Newton isqrt +
+  i64 floor 除算)→ 再帰(1 threadgroup/head・1 thread/列、列局所なので barrier 不要、
+  I128 積で i64 wrap を構造的に排除)→ gated norm(EPS_Q48、2^88/mean、I128 積)→
+  **k_finq128(I128 ベクトル用 fused finish: amax→aq→ys=rne(sfrom(amax,2^60),60))** →
+  ssm_out GEMM → fused finish。GEMM/k_finish は Phase A 検証済みパイプラインを再利用。
+- **状態の GPU 常駐化(Phase D の下準備)**: DState(S 4MB + conv ring 192KB / 層)を Rust 側
+  page-aligned mmap(16K 境界)に置き換え、`newBufferWithBytesNoCopy` で **GPU/CPU が同一
+  ページを共有**(コピーゼロ、CPU fallback・shadow・state_root は同じバイト列を読む)。
+  GPU カーネルが in-place 更新した状態がそのまま state_root へ。
+- **検証(初回ビルドで全通過)**: 単発 smoke(dn 120/120 + moe 160/160)→ 実プロンプト
+  `--ids 760,6511,314,9338,369 --ndecode 8` shadow **dn 390/390 + moe 520/520 全通過**、
+  FNV `57f71e98c68ce514`・route/kv/state root すべて CPU 真値と一致(state_root 一致 =
+  GPU 常駐状態の bit-exact 更新の直接証明)。32-token FNV `8cd22345b5a14c5a` 一致。
+  v1(--metal)回帰・カーネル selftest も全パス。shadow は pre-state snapshot → CPU 再実行 →
+  出力+事後状態(S/ring)完全比較 + 段階レジスタダンプ(DNDBG)を実装。
+  ランタイム前に反証レビュー(カーネル別 7 視点 + 独立検証)をワークフローで並列実施 —
+  **7/7 全員 refuted=false**(bit-exactness への反証ゼロ。指摘は到達不能な headroom メモのみ。
+  唯一の防御的指摘「未知 quant type が Q6_K カーネルへ黙って fallthrough」は Rust 側 assert で
+  CPU と同じ失敗様式に修正済み)。
+- **速度**: 8-token 定常 **3.9s(Phase A 4.0s と同等)**、32-token 11.5s(3.2 tok/s)。
+  PROF 定常: moe 1.94s / dn 1.30-1.35s / gemm_batch 0.30s(269 commits)。
+  dn CB 内訳(stage 打ち切り QI35_DN_STAGE): S1(GEMM+finish)0.82s / +conv+scalars ±0 /
+  +L2+再帰 +0.08s / +gnorm+finq +0.26s / +out GEMM+finish +0.19s → **commit 床 0.82s(61%)、
+  カーネル実行 ~0.5s**。30 CB/token × ~2.1ms が支配項のまま = Phase D(単一 CB 化)の根拠を再確認。
+  finq の単一 tg 128-bit 長除算 4096 回(+0.65ms/層)は emin 別 ratio メモ化で削減可能(未実施)。
+- 意味論の要点(バグゼロで通った理由): CPU が i128 を使う箇所は全て I128 2-word で複製
+  (s*g・kv*dlt・raw*inv30・o24²・v*inv*gm・normed*silu は i64 を溢れ得る)、silu の >>16 は
+  rne でなく算術シフト、L2 の fdiv は負分子の floor 補正付き i64 除算、isqrt は Rust と同一
+  Newton 列(入力 <2^63 で u64 化)、再帰は列局所ゆえ decay→sk→dlt→update→o を同一 thread で。
+
+## 追記 5 — v3 Phase C 完成: full attention on-device + KV cache GPU 常駐が bit-exact 成立 (2026-07-20 夜)
+
+- `qi35_metal_at.m`(新規): **full-attention 10 層の全段を 1 command buffer / ~12 dispatch に
+  on-device 化**。3 GEMM(attn_q 8192 / attn_k 512 / attn_v 512)→ fused finish×3 →
+  `k_at_qknorm`(per-head RMS、per-token eps `u=min(2^60/s,2^40)`、**i128 Newton isqrt** —
+  head セグメントがほぼ零だと 2^88/mean が u64 を超えるため dn の isqrt64 は不可、Rust と
+  同一反復列を I128 divmag で完全複製)→ `k_finq128`×2(**shift 引数化**: dn 60 / qn·kn 44 /
+  at 32 — dn 側は 60 を渡し bit 挙動不変)→ `k_at_rope`(A24 int 上の半回転、Q30 cos/sin
+  テーブル GPU 常駐)→ `k_at_kv`(tofix16 流用で k16/v16 を row=pos に書込 + cq)→
+  `k_at_core`(1 tg/head: I128 スコア内積 → 符号付き max → expn LUT + den → floor 除算 +
+  sigmoid gate)→ finq(32)→ attn_output GEMM → fused finish。GEMM/finish/finq は
+  Phase A/B 検証済みパイプラインを再利用。
+- **KV cache の GPU 常駐(事前確保)**: KvState を Vec→page-aligned mmap(smax=8192 行 ×
+  NKV·HD)へ。`newBufferWithBytesNoCopy` で GPU が in-place append、CPU fallback・shadow・
+  kv_root は同じバイト列を読む。kv_root は len プレフィクスのみハッシュ = 旧 Vec 実装と
+  バイト同一(8tok/32tok の root 完全一致で確認)。
+- **検証(初回ビルドで全通過)**: 単一 token shadow 全層 OK → Hello 8tok(FNV
+  `ff03bf7c9a5d7593` = G3 CPU 真値、生成列一致)→ Paris 8tok(FNV `57f71e98c68ce514` =
+  Phase B 真値)→ **rebind 強制(QI35_KVBIND0=8)shadow 全層 OK** → 32-token FNV
+  `8cd22345b5a14c5a` 一致 + route/kv/state root 一致。
+- **敵対的レビュー(6 視点 + 独立検証)**: confirmed ゼロ(verdict 全 real=false、到達不能
+  領域のみ)。防御修正 2 件を適用: (a) expn LUT の `ix∈[2^63,2^64)` 折返し領域を CPU と同じ
+  0 に固定(device OOB read も排除)、(b) attention_gpu にテンソル幾何 assert(rows/nsb
+  ハードコードの黙殺防止、dn の同型指摘と同じ対応)。適用後 shadow 再 PASS。
+- **perf 退行事件と修正(Phase D への重要な教訓)**: 初版は 64MB×20 の KV バッファを
+  hazard-tracked のまま bind → **バインドしていない moe/dn の CB まで commit が 10× 遅化**
+  (moe 151ms→1.5s/token、v1 は正常 = Phase C 由来と切り分け)。KVMAX=512 で完全回復 =
+  **コストは bind 済みサイズに比例**(per-commit residency/hazard 走査)。untracked 化で
+  部分回復(8192 行: moe 5.8s)。**最終修正 = grow-rebind**: 初期 bind 1024 行/層
+  (`QI35_KVBIND0`)、pos が超えたら同一ページを ×4 で包み直し(データ無傷、〜2 回/8k)、
+  untracked 併用(CB 内は明示 barrier、CB 間は waitUntilCompleted で同期済みのため安全)。
+  → moe 1.93s / dn 1.29s(8tok)= Phase B と同水準。**教訓: 巨大 tracked no-copy バッファは
+  プロセスの全 CB commit に課税する。Phase D の hv 常駐も bind 最小化 + untracked を既定に。**
+- **速度**: 8-token 4.2s(安定、×2 再現)、32-token **10.9s(3.4 tok/s)**、PROF 定常:
+  moe 4.77s / dn 3.63s / at 1.47s / gemm_batch 0.53s(33 commits = LM head のみ)。
+  attention の CB 4ms/層(床 2ms + カーネル 2ms)。トークンあたり CB 80 本(moe40+dn30+at10)
+  が残る床 = Phase D(単一 CB 化)で 20-40 tok/s を狙う構造が完成。
diff --git a/docs/evidence/canonical-int-qwen36-v3-pair-2026-07-20.md b/docs/evidence/canonical-int-qwen36-v3-pair-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..ed450bf436178f970bdd67b3558b2d0e23853621
--- /dev/null
+++ b/docs/evidence/canonical-int-qwen36-v3-pair-2026-07-20.md
@@ -0,0 +1,76 @@
+# Evidence — QI35-8/10: 整数 receipt の palw 統合(ML-DSA/bundle/state-db)+ 実 2 台 cross-vendor k=2 ペア (2026-07-20)
+
+整数エンジンの receipt を **既存 palw フローと同じ土俵**(ML-DSA-87 署名・暗号化 bundle・durable
+state-db)に載せ、**Mac(Apple aarch64)と RTX box(WSL2 x86_64)の実 2 台**で同一ジョブの receipt を
+独立発行 → **receipt-v3 の `match_pair_v3` で正式ペア成立**まで実機で通した記録。
+
+## 実装(runtime-palw、`--features ml-dsa`)
+
+- **`palw-integer-receipt`**(src/bin/): qi35 整数エンジンをサブプロセス実行し、
+  `receipt_v3::ComputeReceiptV3` を構築して **ML-DSA-87 署名**(`sign_receipt_v3`、seed は監査鍵+
+  worker label から導出)。consensus projection(`MatchProjectionV2`)は全て実データ:
+  - `output_commitment` = domain_hash64(network ‖ prompt_commit ‖ output ids)
+  - `route_root` / `execution_root` / `state_root` = エンジンが生成後に出力する **bit-exact digest**
+    (MoE expert route 列 / KV cache 整数列 / DeltaNet 状態+conv 整数列の blake2b256)を domain wrap
+  - `canonical_compute_units` = 既存 `qwen36_semantic_compute_units`(token 数のみの意味論的 CU — 整数
+    エンジンにそのまま適用可能)
+  - `compute_set_id` = model+tables blake2b256 束縛。engine ハッシュは **telemetry**(ADR §3: 実装差は
+    consensus 外)
+  - bundle: **XChaCha20Poly1305**(既存フローと同じ AEAD)で opening(prompt/output ids + digest)を
+    封緘、AAD = receipt_id。state-db: sqlite `integer_receipts`(execution_nullifier UNIQUE = 二重計上防止)
+- **`palw-verify-integer`**: ML-DSA 検証 / credential 束縛(vk→credential 再導出)/ bundle 復号と
+  projection 再計算 / state-db 照合 / `--rerun`(エンジン独立再実行で全 root 再現)/
+  `--pair`(receipt-v3 `match_pair_v3` による k=2 判定)。
+- 新規 domain tag は [receipt-v3-ledger.md](../receipt-v3-ledger.md) §4 に昇格申請行として記録。
+
+## 実機ラン 1 — Mac 発行 + フル検証 15/15 PASS
+
+prompt "The capital of France is"(ids `[760,6511,314,9338,369]`)、n-predict 8:
+
+```
+receipt_id=e16e6181…3be318   signature=ml-dsa-87 (receipt-v3 envelope)
+output_commitment=e0697cf9…e104   canonical_compute_units=77434   durable_receipt_count=1
+検証: ml_dsa_signature / receipt_id / credential_binding / bundle_receipt_binding /
+      output_commitment / route_root / execution_root / state_root / token_count /
+      canonical_compute_units / state_db_row / rerun_output_ids / rerun_route_root /
+      rerun_kv_root / rerun_state_root — 全 PASS
+```
+
+(検証側の初回バグ: stop_reason=length の再実行に max_new=len+1 を渡し 1 token 余分に生成 → 全 root
+不一致。stop_reason で分岐して修正 — 「再実行は停止条件まで含めて再現せよ」という教訓ごと記録。)
+
+## 実機ラン 2 — RTX box(WSL2 x86_64)で独立発行 → commitment 完全一致
+
+- blob 23,938,321,728 bytes を SSH バイナリパイプで転送、blake2b256 **一致**(`fabdc6dc…5326c`)。
+  tables も一致(`8ae72774…f9a4`)。エンジンは WSL 上で rustc 1.96 により**独立ビルド**。
+- 同一 prompt ids / n-predict 8 を worker label `rtx-wsl-x86` で発行:
+
+```
+RTX: output_commitment=e0697cf997e01899f525a4cac6f70a0f7b1f2c91d3ae9c0fc2154cccf324a66c…e104
+Mac: output_commitment=e0697cf997e01899f525a4cac6f70a0f7b1f2c91d3ae9c0fc2154cccf324a66c…e104   ✅ 一致
+```
+
+Apple aarch64 ↔ AMD64/WSL2、別 OS・別ビルド・別スレッド数で **projection が byte 一致**。
+(RAM 21GB の WSL では 24GB blob が mmap ページングになり 8 token 24.6s(Mac 10.0s)— 機能は完全。)
+
+## 実機ラン 3 — k=2 cross-vendor ペア成立
+
+```
+palw-verify-integer --receipt <mac>.integer.json --pair rtx-receipt.json
+  [PASS] ml_dsa_signature  [PASS] pair_ml_dsa_signature  [PASS] k2_pair_match
+pair_id=ce81efa651669a7dd73eac8cfa40c54f117ee0ca3c2bcedea93084c56809038e…c2bf
+```
+
+`match_pair_v3` の要件(同一 network / 独立 worker credential / 独立 nullifier / **projection 全
+フィールド byte-equal**)を実 2 台で満たした。凍結済み ADR §3「cross-vendor ペアは有効、
+runtime_class_id は telemetry」の**最初の実機実証**。
+
+## 正直な限界
+
+- `job_challenge` は自己導出(epoch beacon 未接続)。credential は監査鍵+label 由来(ネットワーク
+  登録 credential ではない)。state-db は専用テーブル(v3 単一台帳 store への統合は v3 本体作業)。
+- mint 適格性は引き続き false(network anchor / bond が無いため)。ただし fp 版の非適格理由のうち
+  「trace がカーネル launch スケッチで accumulator 証明でない」は、整数 class では**再実行で完全再現
+  可能**という強い性質に置き換わっている(qi35-int の route/KV/state root は独立再実行で一致)。
+- WSL 側 CUDA は未使用(CPU x86 で十分に cross-vendor を示せるため。CUDA offload は QI35-5 と同系の
+  高速化作業)。
diff --git a/docs/evidence/gguf_full_dump.py b/docs/evidence/gguf_full_dump.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e0fb7f3786453f728ed549f28b7b9353c2dcb10
--- /dev/null
+++ b/docs/evidence/gguf_full_dump.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+# Full GGUF dump: ALL kv (including array contents for small arrays) + ALL tensor names/shapes/types.
+import struct, sys, json, collections
+
+path = sys.argv[1]
+f = open(path, "rb")
+def rd(fmt):
+    n = struct.calcsize(fmt)
+    return struct.unpack("<" + fmt, f.read(n))[0]
+def rd_str():
+    n = rd("Q")
+    return f.read(n).decode("utf-8", "replace")
+
+magic = f.read(4)
+assert magic == b"GGUF", magic
+ver = rd("I")
+tensor_count = rd("Q")
+kv_count = rd("Q")
+print(f"gguf_version={ver} tensor_count={tensor_count} kv_count={kv_count}")
+
+def read_value(vt, keep_arrays=False):
+    if vt == 8: return rd_str()
+    if vt == 6: return rd("f")
+    if vt == 12: return rd("d")
+    if vt == 7: return bool(rd("B"))
+    if vt == 0: return rd("B")
+    if vt == 1: return rd("b")
+    if vt == 2: return rd("H")
+    if vt == 3: return rd("h")
+    if vt == 4: return rd("I")
+    if vt == 5: return rd("i")
+    if vt == 10: return rd("Q")
+    if vt == 11: return rd("q")
+    if vt == 9:
+        et = rd("I"); cnt = rd("Q")
+        vals = []
+        for _ in range(cnt):
+            v = rd_str() if et == 8 else read_value(et)
+            if cnt <= 64 or keep_arrays:
+                vals.append(v)
+        if cnt <= 64:
+            return vals
+        return f"<array type{et} x{cnt}>"
+    raise ValueError(f"unknown vt {vt}")
+
+for _ in range(kv_count):
+    key = rd_str()
+    vt = rd("I")
+    val = read_value(vt)
+    print(f"KV {key} = {val}")
+
+GGML_TYPES = {0:"F32",1:"F16",2:"Q4_0",3:"Q4_1",6:"Q5_0",7:"Q5_1",8:"Q8_0",9:"Q8_1",
+              10:"Q2_K",11:"Q3_K",12:"Q4_K",13:"Q5_K",14:"Q6_K",15:"Q8_K",
+              16:"IQ2_XXS",17:"IQ2_XS",18:"IQ3_XXS",19:"IQ1_S",20:"IQ4_NL",21:"IQ3_S",
+              22:"IQ2_S",23:"IQ4_XS",24:"I8",25:"I16",26:"I32",27:"I64",28:"F64",29:"IQ1_M",30:"BF16"}
+print("\n=== TENSORS ===")
+by_type = collections.Counter()
+for _ in range(tensor_count):
+    name = rd_str()
+    nd = rd("I")
+    shape = [rd("Q") for _ in range(nd)]
+    ttype = rd("I")
+    off = rd("Q")
+    tn = GGML_TYPES.get(ttype, str(ttype))
+    by_type[tn] += 1
+    print(f"T {name} shape={shape} type={tn} off={off}")
+print("\n=== TYPE SUMMARY ===")
+for t, c in by_type.most_common():
+    print(f"{t}: {c}")
diff --git a/docs/evidence/gguf_meta.py b/docs/evidence/gguf_meta.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fa49c636cb9c130e2cb639891684d98b1be0855
--- /dev/null
+++ b/docs/evidence/gguf_meta.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+# Minimal GGUF metadata reader: print scalar KV (arch / dims / rope / etc).
+import struct, sys
+
+path = sys.argv[1]
+f = open(path, "rb")
+def rd(fmt):
+    n = struct.calcsize(fmt)
+    return struct.unpack("<" + fmt, f.read(n))[0]
+def rd_str():
+    n = rd("Q")
+    return f.read(n).decode("utf-8", "replace")
+
+magic = f.read(4)
+assert magic == b"GGUF", magic
+ver = rd("I")
+tensor_count = rd("Q")
+kv_count = rd("Q")
+print(f"gguf_version={ver} tensor_count={tensor_count} kv_count={kv_count}")
+
+VT = {0:"u8",1:"i8",2:"u16",3:"i16",4:"u32",5:"i32",6:"f32",7:"bool",8:"str",9:"arr",10:"u64",11:"i64",12:"f64"}
+def read_value(vt):
+    if vt == 8: return rd_str()
+    if vt == 6: return rd("f")
+    if vt == 12: return rd("d")
+    if vt == 7: return bool(rd("B"))
+    if vt in (0,): return rd("B")
+    if vt in (1,): return rd("b")
+    if vt in (2,): return rd("H")
+    if vt in (3,): return rd("h")
+    if vt in (4,): return rd("I")
+    if vt in (5,): return rd("i")
+    if vt in (10,): return rd("Q")
+    if vt in (11,): return rd("q")
+    if vt == 9:  # array
+        et = rd("I"); cnt = rd("Q")
+        # skip elements, just report
+        for _ in range(cnt):
+            if et == 8: rd_str()
+            else: read_value(et)
+        return f"<array {VT.get(et,et)} x{cnt}>"
+    raise ValueError(f"unknown vt {vt}")
+
+want = ("architecture","block_count","embedding_length","feed_forward_length","head_count","head_count_kv",
+        "rope","context_length","vocab","attention","layer_norm","key_length","value_length","expert","name","file_type")
+for _ in range(kv_count):
+    key = rd_str()
+    vt = rd("I")
+    val = read_value(vt)
+    if any(w in key for w in want):
+        print(f"{key} = {val}  ({VT.get(vt,vt)})")
diff --git a/docs/evidence/k2-local-match-demo-2026-07-20.md b/docs/evidence/k2-local-match-demo-2026-07-20.md
new file mode 100644
index 0000000000000000000000000000000000000000..f57edc37a4a7ab04af3077459d65ce451576055a
--- /dev/null
+++ b/docs/evidence/k2-local-match-demo-2026-07-20.md
@@ -0,0 +1,56 @@
+# Evidence — ローカル k=2 マッチ・デモ(testnet の最小片)(2026-07-20)
+
+testnet の核である **k=2 レプリカ照合**を、2 つの相補的な実行で「実際に動く」ことを示した記録。
+
+## 半分 1 — 実 matcher パイプラインの end-to-end k=2(runtime-palw、実コード)
+
+`runtime-palw` の既存 k=2 テストは、**本物のパイプライン**(`build_signed_receipt` → `verify_stateless` →
+実 SQLite `StateStore::accept` → `K2Matcher::match_pair` → `MatchedReplicaPair`)を SelfReplicated スロット
+0/1 のレシート対で実行する。ローカル実行結果:
+
+```
+$ cd runtime-palw && cargo test --locked --release --test adversarial k2_
+test k2_allows_one_pair_per_job_independent_of_input_order ... ok
+test k2_rejects_self_pair_fork_duplicate_credential_owner_assignment_and_runtime ... ok
+test result: ok. 2 passed; 0 failed
+```
+
+- 1 本目: 正当な 2 worker の対が **順序に依らず同一 `pair_id` でマッチ**する(受理系)。
+- 2 本目: **自己ペア偽装**(credential / owner / assignment / runtime を重複させた fork)を matcher が
+  **拒否**する(健全性系)。マッチだけでなく「偽の k=2 が通らない」ことまで実コードで確認。
+- 制約(正直): この経路の evidence は合成(GPU 実行なし)。また `palw-metal-receipt` バイナリ経由の
+  2 回実行は**構造的に unmatchable**(毎回 fresh random の `scheduler_job_id`/`output_nonce` →
+  `job_nullifier`/`request_commitment` が一致し得ない + `SelfLocal`/slot0 固定)。実運用の k=2 には
+  scheduler が共有 job を 2 worker に割り当てる plumbing(node 側)が必要 — これは
+  [node 統合仕様](../palw-node-integration-spec.md) §4 の node 責務そのもの。
+
+## 半分 2 — クロスベンダ実機 k=2(実重み・実ハード、MatchProjectionV2 流儀)
+
+半分 1 が示さないもの=「実ハードの独立 2 ベンダが同一ジョブでバイト一致するか」を、canonical-integer
+実行で実施。**worker A = Mac (Rust CPU, aarch64)**、**worker B = RTX 4060 Ti (CUDA GPU, Ada sm_89)** が
+同一ジョブ(実 Qwen2.5-0.5B layer-0 の完全整数 full-layer forward、prompt [9707,11,1879,30])を独立実行:
+
+```
+worker A: Rust CPU (aarch64)
+worker B: NVIDIA CUDA GPU (NVIDIA GeForce RTX 4060 Ti sm_89)
+  A projection digest = 658e2d1d14c67ff8b977e8157e4f9017
+  B projection digest = 658e2d1d14c67ff8b977e8157e4f9017
+  (runtime_class_id EXCLUDED from projection — V2: class is telemetry)
+independence (different backends) : YES
+projection byte-equality          : YES
+K2 VERDICT: MATCHED — cross-vendor k=2 pair accepted
+```
+
+- 射影 = {job, artifact hash(`layer0.bin` blake2b16 `039f00f0…`、両者一致), 出力指紋
+  `906729150a5a926a`, 出力先頭値} — **`runtime_class_id` は意図的に射影から除外**
+  ([ADR Receipt v3](../adr-receipt-v3-node-ownership.md) の MatchProjectionV2 流儀。V1 の class 一致要件の
+  ままでは異機種 bit 一致が永久にマッチ不能)。
+- 成果物: `k2_cross_vendor_match.py`(最小マッチャ)、`workerA.txt` / `workerB.txt`(実行転写)。
+- 制約(正直): これは V2「流儀」のデモ用最小射影であり、本物の `MatchProjectionV2`(compute_set_id /
+  job_challenge / 各 root / CU / stop reason)は Receipt v3 移行(ADR 作業順)で実装される。
+
+## 読み
+
+- 半分 1 = **照合ロジックの実物**が受理も拒否も正しく動く。半分 2 = **実ハードの独立 2 ベンダ**が
+  同一ジョブでバイト一致し、V2 射影でマッチする。合わせて「testnet の最小片」— 残るギャップは
+  scheduler の共有 job 割当(node 側 plumbing)と Receipt v3 の本実装のみで、いずれも既知・文書化済み。
diff --git a/docs/evidence/k2_cross_vendor_match.py b/docs/evidence/k2_cross_vendor_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..396bc550a7e02e596d63f5c2c411ceea40df1e90
--- /dev/null
+++ b/docs/evidence/k2_cross_vendor_match.py
@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+# Local k=2 cross-vendor match demo (MatchProjectionV2-style, per ADR receipt-v3):
+# two independent workers executed the SAME job (canonical integer full-layer forward, real Qwen2.5-0.5B
+# layer-0 weights) on DIFFERENT vendors. Build a projection from each transcript — deliberately WITHOUT
+# runtime_class_id (V2: class is telemetry, not consensus) — and verdict byte-equality.
+import re, sys, hashlib
+
+def parse(path):
+    t = open(path).read()
+    def g(pat):
+        m = re.search(pat, t)
+        return m.group(1).strip() if m else None
+    return {
+        # telemetry (NOT in the projection, per MatchProjectionV2)
+        "telemetry_backend": g(r"backend\s*=\s*(.+)"),
+        # projection fields (consensus)
+        "artifact_blake2b16": g(r"layer0\.bin blake2b16 = ([0-9a-f]+)"),
+        "output_fingerprint": g(r"(?:layer-out|block-out) FNV\s*=\s*([0-9a-f]{16})"),
+        "output_head": ",".join(re.findall(r"-?\d+", g(r"(?:layer|hout)\[0\.\.4\]\s*=\s*(.+)") or "")[:4]),
+    }
+
+A = parse(sys.argv[1]); B = parse(sys.argv[2])
+JOB = "prompt=[9707,11,1879,30];op=canonical-int-fulllayer-l0;alvl=32767;sc=30"
+
+def projection(w):
+    p = f"job:{JOB}|artifact:{w['artifact_blake2b16']}|out:{w['output_fingerprint']}|head:{w['output_head']}"
+    return p, hashlib.blake2b(p.encode(), digest_size=16).hexdigest()
+
+pa, da = projection(A); pb, db = projection(B)
+print(f"worker A: {A['telemetry_backend']}")
+print(f"worker B: {B['telemetry_backend']}")
+print(f"  A projection digest = {da}")
+print(f"  B projection digest = {db}")
+print(f"  (runtime_class_id EXCLUDED from projection — V2: class is telemetry)")
+independent = A["telemetry_backend"] != B["telemetry_backend"]
+matched = (pa == pb)
+print(f"independence (different backends) : {'YES' if independent else 'NO'}")
+print(f"projection byte-equality          : {'YES' if matched else 'NO'}")
+print(f"K2 VERDICT: {'MATCHED — cross-vendor k=2 pair accepted' if (matched and independent) else 'REJECTED'}")
+sys.exit(0 if (matched and independent) else 1)
diff --git a/docs/evidence/libqi35metal.dylib b/docs/evidence/libqi35metal.dylib
new file mode 100644
index 0000000000000000000000000000000000000000..abed6fcec81e4e8e891998179c63e70f476d684e
--- /dev/null
+++ b/docs/evidence/libqi35metal.dylib
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fea5640722ec19158bc21e1bbb2ce3d584b82983b3fa4a12633538b32cac3334
+size 172928
diff --git a/docs/evidence/palw-integer-receipt.rs b/docs/evidence/palw-integer-receipt.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0a393c9ae1a5ac6968039ad69e215e998b0da762
--- /dev/null
+++ b/docs/evidence/palw-integer-receipt.rs
@@ -0,0 +1,592 @@
+// palw-integer-receipt — self-issue a receipt for the CANONICAL INTEGER Qwen3.6-35B engine
+// (qi35_model), on the same footing as palw-metal-receipt: ML-DSA-87 signature (receipt-v3
+// envelope), XChaCha20Poly1305-sealed verification bundle, durable sqlite state-db.
+//
+// The consensus content is a receipt-v3 `MatchProjectionV2` whose roots are the integer engine's
+// bit-exact execution digests (output tokens / MoE expert routes / KV cache / DeltaNet state).
+// Because the integer forward is backend-independent, two receipts for the same job from
+// DIFFERENT machines (e.g. Mac aarch64 + WSL x86_64) carry byte-equal projections and form a
+// valid `match_pair_v3` — runtime_class_id is telemetry only (ADR §3).
+//
+// usage: palw-integer-receipt --prompt-stdin --audit-key-file RAW_32_BYTE_KEY
+//        --output-dir NEW_OR_EMPTY_DIR [--n-predict N] [--engine PATH] [--tables PATH]
+//        [--threads N] [--worker-label LABEL]
+//
+// Honest scope (v0): job_challenge is self-derived (no network beacon), the ML-DSA credential is
+// derived from the local audit key + worker label (not a registered network credential), and the
+// state-db is a dedicated integer-receipt table (not yet the unified v3 single-domain ledger).
+
+use std::error::Error;
+use std::fmt;
+use std::io::Read;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use chacha20poly1305::aead::{Aead, KeyInit, Payload};
+use chacha20poly1305::{XChaCha20Poly1305, XNonce};
+use ml_dsa::{ExpandedSigningKey, MlDsa87};
+use runtime_palw::receipt_v3::mldsa::{sign_receipt_v3, verify_receipt_v3};
+use runtime_palw::receipt_v3::{
+    domain_hash64, ComputeReceiptV3, Hash64, ImplementationTelemetry, MatchProjectionV2,
+};
+use runtime_palw::semantic_cu::qwen36_semantic_compute_units;
+
+const SCHEMA: u16 = 3;
+const RULESET_ID: &str = "qi35-int-v1";
+const NETWORK_LABEL: &[u8] = b"MISAKA-Qwen-PALW-v1";
+const EOS_TOKEN: u32 = 248_046;
+const ISSUED_EPOCH: u64 = 1;
+const EXPIRES_EPOCH: u64 = 1_000_000;
+const MAX_PROMPT_BYTES: u64 = 1 << 20;
+
+#[derive(Debug)]
+struct PublicError(&'static str);
+impl fmt::Display for PublicError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+impl Error for PublicError {}
+
+fn hex(bytes: &[u8]) -> String {
+    let mut s = String::with_capacity(bytes.len() * 2);
+    for b in bytes {
+        s.push_str(&format!("{b:02x}"));
+    }
+    s
+}
+
+// mtime+size keyed cache => model hash costs ~0 after the first issuance ("seconds-scale receipts")
+fn blake2b256_file_cached(path: &Path) -> Result<[u8; 32], Box<dyn Error>> {
+    let meta = std::fs::metadata(path)?;
+    let mtime = meta.modified()?.duration_since(std::time::UNIX_EPOCH)?.as_secs();
+    let key = format!("{}|{}|{}", path.display(), meta.len(), mtime);
+    let cache_path = std::env::temp_dir().join("qi35-hash-cache.txt");
+    if let Ok(cache) = std::fs::read_to_string(&cache_path) {
+        for line in cache.lines() {
+            if let Some(rest) = line.strip_prefix(&format!("{key}=")) {
+                if rest.len() == 64 {
+                    let mut out = [0u8; 32];
+                    for i in 0..32 { out[i] = u8::from_str_radix(&rest[2 * i..2 * i + 2], 16)?; }
+                    return Ok(out);
+                }
+            }
+        }
+    }
+    let h = blake2b256_file(path)?;
+    let mut cache = std::fs::read_to_string(&cache_path).unwrap_or_default();
+    cache.push_str(&format!("{key}={}\n", hex(&h)));
+    let _ = std::fs::write(&cache_path, cache);
+    Ok(h)
+}
+
+fn blake2b256_file(path: &Path) -> Result<[u8; 32], Box<dyn Error>> {
+    let mut f = std::fs::File::open(path)?;
+    let mut hasher = blake2b_simd::Params::new().hash_length(32).to_state();
+    let mut buf = vec![0u8; 1 << 22];
+    loop {
+        let n = f.read(&mut buf)?;
+        if n == 0 {
+            break;
+        }
+        hasher.update(&buf[..n]);
+    }
+    let mut out = [0u8; 32];
+    out.copy_from_slice(hasher.finalize().as_bytes());
+    Ok(out)
+}
+
+fn ids_bytes(ids: &[u32]) -> Vec<u8> {
+    let mut v = Vec::with_capacity(ids.len() * 8);
+    for &i in ids {
+        v.extend_from_slice(&u64::from(i).to_le_bytes());
+    }
+    v
+}
+
+struct Cli {
+    prompt: String,
+    n_predict: u32,
+    output_directory: PathBuf,
+    audit_key_file: PathBuf,
+    engine: PathBuf,
+    tables: PathBuf,
+    threads: u32,
+    worker_label: String,
+    model_override: Option<PathBuf>,
+    prompt_ids_override: Option<Vec<u32>>,
+}
+
+fn parse_cli() -> Result<Cli, Box<dyn Error>> {
+    let mut prompt_stdin = false;
+    let mut n_predict = 8u32;
+    let mut output_directory = None;
+    let mut audit_key_file = None;
+    let mut engine = None;
+    let mut tables = None;
+    let mut threads = 8u32;
+    let mut worker_label = "mac-local".to_owned();
+    let mut model_override = None;
+    let mut prompt_ids_override = None;
+    let mut arguments = std::env::args().skip(1);
+    while let Some(argument) = arguments.next() {
+        match argument.as_str() {
+            "--prompt-stdin" => prompt_stdin = true,
+            "--n-predict" => {
+                n_predict = arguments
+                    .next()
+                    .ok_or(PublicError("--n-predict requires a value"))?
+                    .parse()?;
+            }
+            "--output-dir" => {
+                output_directory = Some(PathBuf::from(
+                    arguments
+                        .next()
+                        .ok_or(PublicError("--output-dir requires a value"))?,
+                ));
+            }
+            "--audit-key-file" => {
+                audit_key_file = Some(PathBuf::from(
+                    arguments
+                        .next()
+                        .ok_or(PublicError("--audit-key-file requires a value"))?,
+                ));
+            }
+            "--engine" => engine = Some(PathBuf::from(arguments.next().ok_or(PublicError("--engine requires a value"))?)),
+            "--tables" => tables = Some(PathBuf::from(arguments.next().ok_or(PublicError("--tables requires a value"))?)),
+            "--threads" => threads = arguments.next().ok_or(PublicError("--threads requires a value"))?.parse()?,
+            "--worker-label" => worker_label = arguments.next().ok_or(PublicError("--worker-label requires a value"))?,
+            "--model" => model_override = Some(PathBuf::from(arguments.next().ok_or(PublicError("--model requires a value"))?)),
+            "--prompt-ids" => {
+                let csv = arguments.next().ok_or(PublicError("--prompt-ids requires a value"))?;
+                let ids: Result<Vec<u32>, _> = csv.split(',').map(str::parse).collect();
+                prompt_ids_override = Some(ids.map_err(|_| PublicError("--prompt-ids must be comma-separated integers"))?);
+            }
+            "--help" | "-h" => {
+                println!(
+                    "usage: palw-integer-receipt --prompt-stdin --audit-key-file RAW_32_BYTE_KEY \
+                     --output-dir NEW_OR_EMPTY_DIR [--n-predict N] [--engine PATH] [--tables PATH] \
+                     [--threads N] [--worker-label LABEL]"
+                );
+                std::process::exit(0);
+            }
+            _ => return Err(PublicError("unknown command-line argument").into()),
+        }
+    }
+    let mut prompt = String::new();
+    if prompt_ids_override.is_none() {
+        if !prompt_stdin {
+            return Err(PublicError("--prompt-stdin (or --prompt-ids) is required").into());
+        }
+        std::io::stdin()
+            .lock()
+            .take(MAX_PROMPT_BYTES + 1)
+            .read_to_string(&mut prompt)?;
+        if u64::try_from(prompt.len())? > MAX_PROMPT_BYTES || prompt.is_empty() {
+            return Err(PublicError("prompt must be non-empty and at most 1 MiB").into());
+        }
+    }
+    let env_or = |key: &str, fallback: Option<PathBuf>| -> Result<PathBuf, Box<dyn Error>> {
+        if let Some(p) = fallback {
+            return Ok(p);
+        }
+        std::env::var(key)
+            .map(PathBuf::from)
+            .map_err(|_| PublicError("engine/tables path missing (flag or env)").into())
+    };
+    Ok(Cli {
+        prompt,
+        n_predict: n_predict.clamp(1, 1024),
+        output_directory: output_directory.ok_or(PublicError("--output-dir is required"))?,
+        audit_key_file: audit_key_file.ok_or(PublicError("--audit-key-file is required"))?,
+        engine: env_or("QI35_ENGINE", engine)?,
+        tables: env_or("QI35_TABLES", tables)?,
+        threads,
+        worker_label,
+        model_override,
+        prompt_ids_override,
+    })
+}
+
+fn tokenize_prompt(tokenizer: &Path, model: &Path, prompt: &str) -> Result<Vec<u32>, Box<dyn Error>> {
+    use std::io::Write;
+    let mut child = Command::new(tokenizer)
+        .arg("--offline")
+        .arg("--model")
+        .arg(model)
+        .arg("--stdin")
+        .arg("--ids")
+        .stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .spawn()?;
+    child
+        .stdin
+        .take()
+        .ok_or(PublicError("tokenizer stdin missing"))?
+        .write_all(prompt.as_bytes())?;
+    let output = child.wait_with_output()?;
+    if !output.status.success() {
+        return Err(PublicError("pinned tokenizer exited unsuccessfully").into());
+    }
+    let stdout = std::str::from_utf8(&output.stdout)?;
+    let line = stdout
+        .lines()
+        .find(|line| line.trim_start().starts_with('['))
+        .ok_or(PublicError("tokenizer emitted no ID array"))?;
+    Ok(serde_json::from_str(line.trim())?)
+}
+
+struct EngineRun {
+    output_ids: Vec<u32>,
+    eos_reached: bool,
+    route_root: [u8; 32],
+    kv_root: [u8; 32],
+    state_root: [u8; 32],
+    seconds: f64,
+}
+
+fn run_engine(cli: &Cli, model: &Path, prompt_ids: &[u32]) -> Result<EngineRun, Box<dyn Error>> {
+    let ids_csv = prompt_ids
+        .iter()
+        .map(u32::to_string)
+        .collect::<Vec<_>>()
+        .join(",");
+    let started = std::time::Instant::now();
+    let extra = std::env::var("QI35_ENGINE_ARGS").unwrap_or_default();
+    let output = Command::new(&cli.engine)
+        .arg(model)
+        .arg(&cli.tables)
+        .args(["--ids", &ids_csv])
+        .args(["--max-new", &cli.n_predict.to_string()])
+        .args(["--eos", &EOS_TOKEN.to_string()])
+        .args(["--threads", &cli.threads.to_string()])
+        .args(extra.split_whitespace())
+        .output()?;
+    if !output.status.success() {
+        return Err(PublicError("integer engine exited unsuccessfully").into());
+    }
+    let seconds = started.elapsed().as_secs_f64();
+    let stdout = std::str::from_utf8(&output.stdout)?;
+    let mut output_ids = None;
+    let mut eos_reached = None;
+    let mut roots: [Option<[u8; 32]>; 3] = [None, None, None];
+    let parse_hex32 = |s: &str| -> Option<[u8; 32]> {
+        let s = s.trim();
+        if s.len() != 64 {
+            return None;
+        }
+        let mut out = [0u8; 32];
+        for i in 0..32 {
+            out[i] = u8::from_str_radix(&s[2 * i..2 * i + 2], 16).ok()?;
+        }
+        Some(out)
+    };
+    for line in stdout.lines() {
+        if let Some(rest) = line.strip_prefix("generated = ") {
+            let cleaned = rest.trim().trim_start_matches('[').trim_end_matches(']');
+            let ids: Vec<u32> = cleaned
+                .split(',')
+                .map(str::trim)
+                .filter(|s| !s.is_empty())
+                .map(str::parse)
+                .collect::<Result<_, _>>()?;
+            output_ids = Some(ids);
+        } else if let Some(rest) = line.strip_prefix("eos_reached = ") {
+            eos_reached = Some(rest.trim() == "true");
+        } else if let Some(rest) = line.strip_prefix("route_root = ") {
+            roots[0] = parse_hex32(rest);
+        } else if let Some(rest) = line.strip_prefix("kv_root = ") {
+            roots[1] = parse_hex32(rest);
+        } else if let Some(rest) = line.strip_prefix("state_root = ") {
+            roots[2] = parse_hex32(rest);
+        }
+    }
+    Ok(EngineRun {
+        output_ids: output_ids.ok_or(PublicError("engine emitted no generated ids"))?,
+        eos_reached: eos_reached.ok_or(PublicError("engine emitted no eos flag"))?,
+        route_root: roots[0].ok_or(PublicError("engine emitted no route root"))?,
+        kv_root: roots[1].ok_or(PublicError("engine emitted no kv root"))?,
+        state_root: roots[2].ok_or(PublicError("engine emitted no state root"))?,
+        seconds,
+    })
+}
+
+fn main() {
+    if let Err(error) = run() {
+        eprintln!("palw-integer-receipt: {error}");
+        std::process::exit(1);
+    }
+}
+
+#[allow(clippy::too_many_lines)]
+fn run() -> Result<(), Box<dyn Error>> {
+    let workspace = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .ok_or(PublicError("runtime crate has no workspace parent"))?;
+    let cli = parse_cli()?;
+    std::fs::create_dir_all(&cli.output_directory)?;
+
+    let audit_key = std::fs::read(&cli.audit_key_file)?;
+    if audit_key.len() != 32 {
+        return Err(PublicError("audit key must be exactly 32 raw bytes").into());
+    }
+
+    let model = cli.model_override.clone().unwrap_or_else(|| {
+        workspace.join(
+            "models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+        )
+    });
+    let prompt_ids = match &cli.prompt_ids_override {
+        Some(ids) => ids.clone(),
+        None => {
+            let tokenizer = workspace.join("vendor/llama.cpp/build-palw/bin/llama-tokenize");
+            tokenize_prompt(&tokenizer, &model, &cli.prompt)?
+        }
+    };
+    if prompt_ids.is_empty() {
+        return Err(PublicError("prompt token list is empty").into());
+    }
+
+    eprintln!("hashing artifacts (model/tables/engine, blake2b256)...");
+    let model_hash = blake2b256_file_cached(&model)?;
+    let tables_hash = blake2b256_file_cached(&cli.tables)?;
+    let engine_hash = blake2b256_file_cached(&cli.engine)?;
+
+    eprintln!("running canonical integer engine ({} prompt tokens, n_predict {})...", prompt_ids.len(), cli.n_predict);
+    let run = run_engine(&cli, &model, &prompt_ids)?;
+    eprintln!("engine done: {} output tokens in {:.2}s", run.output_ids.len(), run.seconds);
+
+    // ---- consensus projection (all Hash64, byte-equal across backends) ----
+    let network_id = domain_hash64("qi35-network/v3", SCHEMA, &[NETWORK_LABEL]);
+    let prompt_commitment = domain_hash64(
+        "qi35-prompt/v3",
+        SCHEMA,
+        &[&network_id, &ids_bytes(&prompt_ids)],
+    );
+    let output_commitment = domain_hash64(
+        "qi35-output/v3",
+        SCHEMA,
+        &[&network_id, &prompt_commitment, &ids_bytes(&run.output_ids)],
+    );
+    let compute_set_id = domain_hash64(
+        "qi35-compute-set/v3",
+        SCHEMA,
+        &[&model_hash, &tables_hash, RULESET_ID.as_bytes()],
+    );
+    // honest v0: self-derived challenge (no epoch beacon yet); equal across replicas by design
+    let job_challenge = domain_hash64(
+        "qi35-self-challenge/v3",
+        SCHEMA,
+        &[&network_id, &prompt_commitment, &cli.n_predict.to_le_bytes()],
+    );
+    let schedule_root = domain_hash64(
+        "qi35-schedule/v3",
+        SCHEMA,
+        &[
+            RULESET_ID.as_bytes(),
+            &(prompt_ids.len() as u64).to_le_bytes(),
+            &u64::from(cli.n_predict).to_le_bytes(),
+            &u64::from(EOS_TOKEN).to_le_bytes(),
+        ],
+    );
+    let execution_root = domain_hash64("qi35-exec-kv/v3", SCHEMA, &[&run.kv_root]);
+    let route_root = domain_hash64("qi35-exec-route/v3", SCHEMA, &[&run.route_root]);
+    let state_root = domain_hash64("qi35-exec-state/v3", SCHEMA, &[&run.state_root]);
+    let prefill = u32::try_from(prompt_ids.len())?;
+    let generated = u32::try_from(run.output_ids.len())?;
+    let canonical_compute_units = qwen36_semantic_compute_units(prefill, generated);
+    let projection = MatchProjectionV2 {
+        compute_set_id,
+        job_challenge,
+        output_commitment,
+        schedule_root,
+        execution_root,
+        route_root,
+        state_root,
+        canonical_compute_units,
+        token_count: u64::from(prefill) + u64::from(generated),
+        stop_reason: if run.eos_reached { 1 } else { 2 },
+    };
+
+    // ---- worker credential: ML-DSA-87 key derived from audit key + worker label (v0) ----
+    let seed64 = domain_hash64(
+        "qi35-mldsa-seed/v1",
+        SCHEMA,
+        &[&audit_key, cli.worker_label.as_bytes()],
+    );
+    let mut seed = [0u8; 32];
+    seed.copy_from_slice(&seed64[..32]);
+    let signing_key = ExpandedSigningKey::<MlDsa87>::from_seed(&seed.into());
+    let verifying_key = signing_key.verifying_key().encode().to_vec();
+    let worker_credential_id: Hash64 =
+        domain_hash64("qi35-credential/v3", SCHEMA, &[&verifying_key]);
+
+    let timestamp_millis = u64::try_from(
+        SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis(),
+    )?;
+    let execution_nullifier = domain_hash64(
+        "qi35-nullifier/v3",
+        SCHEMA,
+        &[
+            &worker_credential_id,
+            &prompt_commitment,
+            &output_commitment,
+            &timestamp_millis.to_le_bytes(),
+            &std::process::id().to_le_bytes(),
+        ],
+    );
+
+    let receipt = ComputeReceiptV3 {
+        receipt_version: 3,
+        network_id,
+        projection,
+        telemetry: ImplementationTelemetry {
+            runtime_class_id: {
+                let d = domain_hash64("qi35-runtime-class/v0", SCHEMA, &[b"rust-cpu-integer"]);
+                let mut t = [0u8; 32];
+                t.copy_from_slice(&d[..32]);
+                t
+            },
+            runtime_manifest_hash: engine_hash,
+        },
+        worker_credential_id,
+        execution_nullifier,
+        issued_epoch: ISSUED_EPOCH,
+        expires_epoch: EXPIRES_EPOCH,
+    };
+    let (envelope, vk_bytes) = sign_receipt_v3(&receipt, &seed, worker_credential_id)
+        .map_err(|_| PublicError("ML-DSA signing failed"))?;
+    verify_receipt_v3(&receipt, &envelope, &vk_bytes)
+        .map_err(|_| PublicError("self-verification of the fresh receipt failed"))?;
+    let receipt_id = receipt.receipt_id();
+
+    // ---- public receipt JSON (no ids, no key material besides the public vk) ----
+    let public = serde_json::json!({
+        "schema": "palw.integer-receipt/v3-envelope",
+        "class": "canonical_integer_v0",
+        "receipt_version": 3,
+        "network_id": hex(&receipt.network_id),
+        "receipt_id": hex(&receipt_id),
+        "projection": {
+            "compute_set_id": hex(&receipt.projection.compute_set_id),
+            "job_challenge": hex(&receipt.projection.job_challenge),
+            "output_commitment": hex(&receipt.projection.output_commitment),
+            "schedule_root": hex(&receipt.projection.schedule_root),
+            "execution_root": hex(&receipt.projection.execution_root),
+            "route_root": hex(&receipt.projection.route_root),
+            "state_root": hex(&receipt.projection.state_root),
+            "canonical_compute_units": receipt.projection.canonical_compute_units,
+            "token_count": receipt.projection.token_count,
+            "stop_reason": receipt.projection.stop_reason,
+        },
+        "telemetry": {
+            "runtime_class_id": hex(&receipt.telemetry.runtime_class_id),
+            "runtime_manifest_hash": hex(&receipt.telemetry.runtime_manifest_hash),
+        },
+        "worker_credential_id": hex(&receipt.worker_credential_id),
+        "execution_nullifier": hex(&receipt.execution_nullifier),
+        "issued_epoch": receipt.issued_epoch,
+        "expires_epoch": receipt.expires_epoch,
+        "envelope": {
+            "body_digest": hex(&envelope.body_digest),
+            "algorithm": envelope.algorithm,
+            "signer_credential_id": hex(&envelope.signer_credential_id),
+            "signature": hex(&envelope.signature),
+        },
+        "verifying_key": hex(&vk_bytes),
+        "artifacts": {
+            "model_blake2b256": hex(&model_hash),
+            "tables_blake2b256": hex(&tables_hash),
+            "engine_blake2b256": hex(&engine_hash),
+            "ruleset_id": RULESET_ID,
+        },
+        "prompt_tokens": prefill,
+        "output_tokens": generated,
+        "worker_label": cli.worker_label,
+        "timestamp_millis": timestamp_millis,
+        "engine_seconds": run.seconds,
+    });
+    let public_bytes = serde_json::to_vec_pretty(&public)?;
+
+    // ---- sealed verification bundle (opening): XChaCha20Poly1305, AAD = receipt_id ----
+    let opening = serde_json::json!({
+        "prompt_ids": prompt_ids,
+        "output_ids": run.output_ids,
+        "engine_route_digest": hex(&run.route_root),
+        "engine_kv_digest": hex(&run.kv_root),
+        "engine_state_digest": hex(&run.state_root),
+        "worker_label": cli.worker_label,
+    });
+    let key64 = domain_hash64("qi35-bundle-key/v1", SCHEMA, &[&audit_key, &receipt_id]);
+    let nonce64 = domain_hash64(
+        "qi35-bundle-nonce/v1",
+        SCHEMA,
+        &[&receipt_id, &timestamp_millis.to_le_bytes()],
+    );
+    let cipher = XChaCha20Poly1305::new_from_slice(&key64[..32])
+        .map_err(|_| PublicError("bundle key derivation failed"))?;
+    let nonce = XNonce::from_slice(&nonce64[..24]);
+    let ciphertext = cipher
+        .encrypt(
+            nonce,
+            Payload {
+                msg: &serde_json::to_vec(&opening)?,
+                aad: &receipt_id,
+            },
+        )
+        .map_err(|_| PublicError("bundle sealing failed"))?;
+    let mut bundle = Vec::new();
+    bundle.extend_from_slice(b"QI35BND1");
+    bundle.extend_from_slice(&receipt_id);
+    bundle.extend_from_slice(&nonce64[..24]);
+    bundle.extend_from_slice(&ciphertext);
+
+    // ---- durable state-db (dedicated integer-receipt table; nullifier UNIQUE) ----
+    let db_path = cli.output_directory.join("qi35-state.sqlite3");
+    let conn = rusqlite::Connection::open(&db_path)?;
+    conn.execute_batch(
+        "PRAGMA journal_mode=WAL;
+         CREATE TABLE IF NOT EXISTS integer_receipts (
+             receipt_id TEXT PRIMARY KEY,
+             execution_nullifier TEXT UNIQUE NOT NULL,
+             worker_credential_id TEXT NOT NULL,
+             output_commitment TEXT NOT NULL,
+             timestamp_millis INTEGER NOT NULL,
+             public_json TEXT NOT NULL,
+             bundle BLOB NOT NULL
+         );",
+    )?;
+    conn.execute(
+        "INSERT INTO integer_receipts \
+         (receipt_id, execution_nullifier, worker_credential_id, output_commitment, timestamp_millis, public_json, bundle) \
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
+        rusqlite::params![
+            hex(&receipt_id),
+            hex(&execution_nullifier),
+            hex(&worker_credential_id),
+            hex(&receipt.projection.output_commitment),
+            timestamp_millis,
+            String::from_utf8(public_bytes.clone())?,
+            bundle,
+        ],
+    )?;
+    let durable: u64 = conn.query_row("SELECT COUNT(*) FROM integer_receipts", [], |r| r.get(0))?;
+
+    let rid_hex = hex(&receipt_id);
+    let receipt_path = cli.output_directory.join(format!("{rid_hex}.integer.json"));
+    let bundle_path = cli.output_directory.join(format!("{rid_hex}.integer.bundle"));
+    std::fs::write(&receipt_path, &public_bytes)?;
+    std::fs::write(&bundle_path, &bundle)?;
+
+    println!("receipt_id={rid_hex}");
+    println!("receipt={}", receipt_path.display());
+    println!("verification_bundle={}", bundle_path.display());
+    println!("state_db={}", db_path.display());
+    println!("output_commitment={}", hex(&receipt.projection.output_commitment));
+    println!("canonical_compute_units={canonical_compute_units}");
+    println!("signature=ml-dsa-87 (receipt-v3 envelope)");
+    println!("durable_receipt_count={durable}");
+    Ok(())
+}
diff --git a/docs/evidence/palw-verify-integer.rs b/docs/evidence/palw-verify-integer.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7dc250a1a4fb0070ddbaaf40030da487cd3b2fed
--- /dev/null
+++ b/docs/evidence/palw-verify-integer.rs
@@ -0,0 +1,391 @@
+// palw-verify-integer — verify a canonical-integer receipt issued by palw-integer-receipt.
+//
+// Checks, fail-closed:
+//   1. ML-DSA-87 envelope over the reconstructed receipt-v3 body (digest + signature)
+//   2. receipt_id consistency
+//   3. sealed bundle opens under the audit key (XChaCha20Poly1305, AAD = receipt_id)
+//   4. projection commitments recompute from the opening (prompt/output ids + engine digests)
+//   5. state-db row exists and stores the same public json (when --state-db given)
+//   6. --rerun: independently re-runs the integer engine and requires byte-equal
+//      output ids + route/kv/state digests (the cross-backend reproduction check)
+//   7. --pair OTHER.json: receipt-v3 k=2 match (match_pair_v3) — cross-vendor pairs valid
+//
+// usage: palw-verify-integer --receipt FILE.json --bundle FILE.bundle --audit-key-file KEY
+//        [--state-db FILE] [--rerun --engine PATH --tables PATH [--threads N]] [--pair OTHER.json]
+
+use std::error::Error;
+use std::fmt;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use chacha20poly1305::aead::{Aead, KeyInit, Payload};
+use chacha20poly1305::{XChaCha20Poly1305, XNonce};
+use runtime_palw::receipt_v3::mldsa::verify_receipt_v3;
+use runtime_palw::receipt_v3::{
+    domain_hash64, match_pair_v3, ComputeReceiptV3, Hash64, ImplementationTelemetry,
+    MatchProjectionV2, SignedEnvelopeV3,
+};
+use runtime_palw::semantic_cu::qwen36_semantic_compute_units;
+
+const SCHEMA: u16 = 3;
+const EOS_TOKEN: u32 = 248_046;
+
+#[derive(Debug)]
+struct PublicError(String);
+impl fmt::Display for PublicError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+impl Error for PublicError {}
+fn err(msg: impl Into<String>) -> Box<dyn Error> {
+    Box::new(PublicError(msg.into()))
+}
+
+fn unhex(s: &str) -> Result<Vec<u8>, Box<dyn Error>> {
+    if s.len() % 2 != 0 {
+        return Err(err("odd hex length"));
+    }
+    (0..s.len() / 2)
+        .map(|i| u8::from_str_radix(&s[2 * i..2 * i + 2], 16).map_err(|_| err("bad hex")))
+        .collect()
+}
+fn unhex64(s: &str) -> Result<Hash64, Box<dyn Error>> {
+    let v = unhex(s)?;
+    let mut out = [0u8; 64];
+    if v.len() != 64 {
+        return Err(err("expected 64-byte hex"));
+    }
+    out.copy_from_slice(&v);
+    Ok(out)
+}
+fn unhex32(s: &str) -> Result<[u8; 32], Box<dyn Error>> {
+    let v = unhex(s)?;
+    let mut out = [0u8; 32];
+    if v.len() != 32 {
+        return Err(err("expected 32-byte hex"));
+    }
+    out.copy_from_slice(&v);
+    Ok(out)
+}
+fn hexs(b: &[u8]) -> String {
+    b.iter().map(|x| format!("{x:02x}")).collect()
+}
+fn ids_bytes(ids: &[u64]) -> Vec<u8> {
+    let mut v = Vec::with_capacity(ids.len() * 8);
+    for &i in ids {
+        v.extend_from_slice(&i.to_le_bytes());
+    }
+    v
+}
+
+fn receipt_from_json(v: &serde_json::Value) -> Result<(ComputeReceiptV3, SignedEnvelopeV3, Vec<u8>), Box<dyn Error>> {
+    let s = |ptr: &str| -> Result<&str, Box<dyn Error>> {
+        v.pointer(ptr)
+            .and_then(serde_json::Value::as_str)
+            .ok_or_else(|| err(format!("missing field {ptr}")))
+    };
+    let n = |ptr: &str| -> Result<u64, Box<dyn Error>> {
+        v.pointer(ptr)
+            .and_then(serde_json::Value::as_u64)
+            .ok_or_else(|| err(format!("missing field {ptr}")))
+    };
+    let receipt = ComputeReceiptV3 {
+        receipt_version: u16::try_from(n("/receipt_version")?)?,
+        network_id: unhex64(s("/network_id")?)?,
+        projection: MatchProjectionV2 {
+            compute_set_id: unhex64(s("/projection/compute_set_id")?)?,
+            job_challenge: unhex64(s("/projection/job_challenge")?)?,
+            output_commitment: unhex64(s("/projection/output_commitment")?)?,
+            schedule_root: unhex64(s("/projection/schedule_root")?)?,
+            execution_root: unhex64(s("/projection/execution_root")?)?,
+            route_root: unhex64(s("/projection/route_root")?)?,
+            state_root: unhex64(s("/projection/state_root")?)?,
+            canonical_compute_units: n("/projection/canonical_compute_units")?,
+            token_count: n("/projection/token_count")?,
+            stop_reason: u8::try_from(n("/projection/stop_reason")?)?,
+        },
+        telemetry: ImplementationTelemetry {
+            runtime_class_id: unhex32(s("/telemetry/runtime_class_id")?)?,
+            runtime_manifest_hash: unhex32(s("/telemetry/runtime_manifest_hash")?)?,
+        },
+        worker_credential_id: unhex64(s("/worker_credential_id")?)?,
+        execution_nullifier: unhex64(s("/execution_nullifier")?)?,
+        issued_epoch: n("/issued_epoch")?,
+        expires_epoch: n("/expires_epoch")?,
+    };
+    let envelope = SignedEnvelopeV3 {
+        body_digest: unhex64(s("/envelope/body_digest")?)?,
+        algorithm: u8::try_from(n("/envelope/algorithm")?)?,
+        signer_credential_id: unhex64(s("/envelope/signer_credential_id")?)?,
+        signature: unhex(s("/envelope/signature")?)?,
+    };
+    let vk = unhex(s("/verifying_key")?)?;
+    Ok((receipt, envelope, vk))
+}
+
+struct Cli {
+    receipt: PathBuf,
+    bundle: Option<PathBuf>,
+    audit_key_file: Option<PathBuf>,
+    state_db: Option<PathBuf>,
+    rerun: bool,
+    engine: Option<PathBuf>,
+    tables: Option<PathBuf>,
+    threads: u32,
+    pair: Option<PathBuf>,
+    model_override: Option<PathBuf>,
+}
+
+fn parse_cli() -> Result<Cli, Box<dyn Error>> {
+    let mut cli = Cli {
+        receipt: PathBuf::new(),
+        bundle: None,
+        audit_key_file: None,
+        state_db: None,
+        rerun: false,
+        engine: std::env::var("QI35_ENGINE").ok().map(PathBuf::from),
+        tables: std::env::var("QI35_TABLES").ok().map(PathBuf::from),
+        threads: 8,
+        pair: None,
+        model_override: None,
+    };
+    let mut receipt = None;
+    let mut arguments = std::env::args().skip(1);
+    while let Some(argument) = arguments.next() {
+        let mut val = |name: &str| -> Result<String, Box<dyn Error>> {
+            arguments.next().ok_or_else(|| err(format!("{name} requires a value")))
+        };
+        match argument.as_str() {
+            "--receipt" => receipt = Some(PathBuf::from(val("--receipt")?)),
+            "--bundle" => cli.bundle = Some(PathBuf::from(val("--bundle")?)),
+            "--audit-key-file" => cli.audit_key_file = Some(PathBuf::from(val("--audit-key-file")?)),
+            "--state-db" => cli.state_db = Some(PathBuf::from(val("--state-db")?)),
+            "--rerun" => cli.rerun = true,
+            "--engine" => cli.engine = Some(PathBuf::from(val("--engine")?)),
+            "--tables" => cli.tables = Some(PathBuf::from(val("--tables")?)),
+            "--threads" => cli.threads = val("--threads")?.parse()?,
+            "--pair" => cli.pair = Some(PathBuf::from(val("--pair")?)),
+            "--model" => cli.model_override = Some(PathBuf::from(val("--model")?)),
+            "--help" | "-h" => {
+                println!(
+                    "usage: palw-verify-integer --receipt FILE.json [--bundle FILE.bundle \
+                     --audit-key-file KEY] [--state-db FILE] [--rerun --engine E --tables T] \
+                     [--pair OTHER.json]"
+                );
+                std::process::exit(0);
+            }
+            _ => return Err(err("unknown command-line argument")),
+        }
+    }
+    cli.receipt = receipt.ok_or_else(|| err("--receipt is required"))?;
+    Ok(cli)
+}
+
+#[allow(clippy::too_many_lines)]
+fn run() -> Result<(), Box<dyn Error>> {
+    let workspace = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .ok_or_else(|| err("runtime crate has no workspace parent"))?;
+    let cli = parse_cli()?;
+    let json: serde_json::Value = serde_json::from_slice(&std::fs::read(&cli.receipt)?)?;
+    let (receipt, envelope, vk) = receipt_from_json(&json)?;
+    let mut checks: Vec<(&str, bool)> = Vec::new();
+
+    // 1. ML-DSA-87 signature over the reconstructed body
+    let sig_ok = verify_receipt_v3(&receipt, &envelope, &vk).is_ok();
+    checks.push(("ml_dsa_signature", sig_ok));
+    // 2. receipt_id consistency
+    let rid = receipt.receipt_id();
+    let rid_json = json
+        .get("receipt_id")
+        .and_then(serde_json::Value::as_str)
+        .ok_or_else(|| err("receipt_id missing"))?;
+    checks.push(("receipt_id", hexs(&rid) == rid_json));
+    // credential binding: envelope signer == body credential == hash(vk)
+    let vk_credential = domain_hash64("qi35-credential/v3", SCHEMA, &[&vk]);
+    checks.push((
+        "credential_binding",
+        envelope.signer_credential_id == receipt.worker_credential_id
+            && vk_credential == receipt.worker_credential_id,
+    ));
+
+    // 3-4. bundle opening + commitment recomputation
+    let mut opening_ids: Option<(Vec<u64>, Vec<u64>)> = None;
+    if let (Some(bundle_path), Some(key_path)) = (&cli.bundle, &cli.audit_key_file) {
+        let audit_key = std::fs::read(key_path)?;
+        let bundle = std::fs::read(bundle_path)?;
+        if bundle.len() < 8 + 64 + 24 || &bundle[..8] != b"QI35BND1" {
+            return Err(err("bundle header invalid"));
+        }
+        let rid_b = &bundle[8..72];
+        checks.push(("bundle_receipt_binding", rid_b == rid.as_slice()));
+        let nonce = XNonce::from_slice(&bundle[72..96]);
+        let key64 = domain_hash64("qi35-bundle-key/v1", SCHEMA, &[&audit_key, &rid]);
+        let cipher = XChaCha20Poly1305::new_from_slice(&key64[..32]).map_err(|_| err("key"))?;
+        let plain = cipher
+            .decrypt(nonce, Payload { msg: &bundle[96..], aad: &rid })
+            .map_err(|_| err("bundle decryption failed (wrong audit key or tampered)"))?;
+        let opening: serde_json::Value = serde_json::from_slice(&plain)?;
+        let get_ids = |k: &str| -> Result<Vec<u64>, Box<dyn Error>> {
+            opening
+                .get(k)
+                .and_then(serde_json::Value::as_array)
+                .ok_or_else(|| err(format!("opening missing {k}")))?
+                .iter()
+                .map(|x| x.as_u64().ok_or_else(|| err("bad id")))
+                .collect()
+        };
+        let prompt_ids = get_ids("prompt_ids")?;
+        let output_ids = get_ids("output_ids")?;
+        let route_d = unhex32(opening["engine_route_digest"].as_str().ok_or_else(|| err("route digest"))?)?;
+        let kv_d = unhex32(opening["engine_kv_digest"].as_str().ok_or_else(|| err("kv digest"))?)?;
+        let state_d = unhex32(opening["engine_state_digest"].as_str().ok_or_else(|| err("state digest"))?)?;
+
+        let prompt_commitment = domain_hash64(
+            "qi35-prompt/v3",
+            SCHEMA,
+            &[&receipt.network_id, &ids_bytes(&prompt_ids)],
+        );
+        let output_commitment = domain_hash64(
+            "qi35-output/v3",
+            SCHEMA,
+            &[&receipt.network_id, &prompt_commitment, &ids_bytes(&output_ids)],
+        );
+        checks.push(("output_commitment(opening)", output_commitment == receipt.projection.output_commitment));
+        checks.push(("route_root(opening)", domain_hash64("qi35-exec-route/v3", SCHEMA, &[&route_d]) == receipt.projection.route_root));
+        checks.push(("execution_root(opening)", domain_hash64("qi35-exec-kv/v3", SCHEMA, &[&kv_d]) == receipt.projection.execution_root));
+        checks.push(("state_root(opening)", domain_hash64("qi35-exec-state/v3", SCHEMA, &[&state_d]) == receipt.projection.state_root));
+        let prefill = u32::try_from(prompt_ids.len())?;
+        let generated = u32::try_from(output_ids.len())?;
+        checks.push(("token_count", receipt.projection.token_count == u64::from(prefill) + u64::from(generated)));
+        checks.push(("canonical_compute_units", receipt.projection.canonical_compute_units == qwen36_semantic_compute_units(prefill, generated)));
+        opening_ids = Some((prompt_ids, output_ids));
+    }
+
+    // 5. state-db row
+    if let Some(db) = &cli.state_db {
+        let conn = rusqlite::Connection::open(db)?;
+        let row: Result<String, _> = conn.query_row(
+            "SELECT public_json FROM integer_receipts WHERE receipt_id = ?1",
+            [hexs(&rid)],
+            |r| r.get(0),
+        );
+        match row {
+            Ok(stored) => {
+                let stored_v: serde_json::Value = serde_json::from_str(&stored)?;
+                checks.push(("state_db_row", stored_v == json));
+            }
+            Err(_) => checks.push(("state_db_row", false)),
+        }
+    }
+
+    // 6. independent engine re-run (the cross-backend reproduction check)
+    if cli.rerun {
+        let (prompt_ids, output_ids) = opening_ids
+            .as_ref()
+            .ok_or_else(|| err("--rerun requires --bundle and --audit-key-file"))?;
+        let engine = cli.engine.as_ref().ok_or_else(|| err("--rerun requires --engine"))?;
+        let tables = cli.tables.as_ref().ok_or_else(|| err("--rerun requires --tables"))?;
+        let model = cli.model_override.clone().unwrap_or_else(|| {
+            workspace.join(
+                "models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+            )
+        });
+        let ids_csv = prompt_ids.iter().map(u64::to_string).collect::<Vec<_>>().join(",");
+        // stop_reason 1 (eos): allow one extra step so the engine re-hits EOS and breaks
+        // (no extra forward). stop_reason 2 (length): exactly len steps reproduces the state.
+        let max_new = if receipt.projection.stop_reason == 1 {
+            output_ids.len() + 1
+        } else {
+            output_ids.len()
+        };
+        let extra = std::env::var("QI35_ENGINE_ARGS").unwrap_or_default();
+        let out = Command::new(engine)
+            .arg(&model)
+            .arg(tables)
+            .args(["--ids", &ids_csv])
+            .args(["--max-new", &max_new.to_string()])
+            .args(["--eos", &EOS_TOKEN.to_string()])
+            .args(["--threads", &cli.threads.to_string()])
+            .args(extra.split_whitespace())
+            .output()?;
+        let stdout = String::from_utf8_lossy(&out.stdout).into_owned();
+        let mut rerun_ids: Vec<u64> = Vec::new();
+        let mut roots = std::collections::HashMap::new();
+        for line in stdout.lines() {
+            if let Some(rest) = line.strip_prefix("generated = ") {
+                rerun_ids = rest
+                    .trim()
+                    .trim_start_matches('[')
+                    .trim_end_matches(']')
+                    .split(',')
+                    .map(str::trim)
+                    .filter(|s| !s.is_empty())
+                    .map(|s| s.parse().unwrap_or(u64::MAX))
+                    .collect();
+            }
+            for key in ["route_root", "kv_root", "state_root"] {
+                if let Some(rest) = line.strip_prefix(&format!("{key} = ")) {
+                    roots.insert(key, rest.trim().to_owned());
+                }
+            }
+        }
+        checks.push(("rerun_output_ids", &rerun_ids == output_ids));
+        checks.push((
+            "rerun_route_root",
+            roots.get("route_root").is_some_and(|h| {
+                domain_hash64("qi35-exec-route/v3", SCHEMA, &[&unhex32(h).unwrap_or_default()])
+                    == receipt.projection.route_root
+            }),
+        ));
+        checks.push((
+            "rerun_kv_root",
+            roots.get("kv_root").is_some_and(|h| {
+                domain_hash64("qi35-exec-kv/v3", SCHEMA, &[&unhex32(h).unwrap_or_default()])
+                    == receipt.projection.execution_root
+            }),
+        ));
+        checks.push((
+            "rerun_state_root",
+            roots.get("state_root").is_some_and(|h| {
+                domain_hash64("qi35-exec-state/v3", SCHEMA, &[&unhex32(h).unwrap_or_default()])
+                    == receipt.projection.state_root
+            }),
+        ));
+    }
+
+    // 7. k=2 pair (cross-vendor)
+    if let Some(pair_path) = &cli.pair {
+        let other_json: serde_json::Value = serde_json::from_slice(&std::fs::read(pair_path)?)?;
+        let (other, other_env, other_vk) = receipt_from_json(&other_json)?;
+        checks.push(("pair_ml_dsa_signature", verify_receipt_v3(&other, &other_env, &other_vk).is_ok()));
+        match match_pair_v3(&receipt, &other) {
+            Ok(pair) => {
+                checks.push(("k2_pair_match", true));
+                println!("pair_id={}", hexs(&pair.pair_id));
+            }
+            Err(e) => {
+                checks.push(("k2_pair_match", false));
+                println!("pair_error={e:?}");
+            }
+        }
+    }
+
+    println!("receipt_id={}", hexs(&rid));
+    println!("class=canonical_integer_v0 signature=ml-dsa-87");
+    let mut all = true;
+    for (name, ok) in &checks {
+        println!("  [{}] {}", if *ok { "PASS" } else { "FAIL" }, name);
+        all = all && *ok;
+    }
+    println!("VERIFY: {}", if all { "PASS" } else { "FAIL" });
+    if all { Ok(()) } else { Err(err("verification failed")) }
+}
+
+fn main() {
+    if let Err(error) = run() {
+        eprintln!("palw-verify-integer: {error}");
+        std::process::exit(1);
+    }
+}
diff --git a/docs/evidence/palw_fp_dump.cpp b/docs/evidence/palw_fp_dump.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d2f4b670d7b0e466b03328ebae7dbf57de53fbb3
--- /dev/null
+++ b/docs/evidence/palw_fp_dump.cpp
@@ -0,0 +1,150 @@
+// palw_fp_dump — full-tensor fp32 activation dumper for the qwen35moe graph.
+// Based on examples/eval-callback; dumps EVERY element of tensors whose ggml
+// name matches one of the PALW_DUMP_FILTER regexes (comma-separated) into
+// PALW_DUMP_DIR as s{step}_{sanitized_name}.bin:
+//   header: "PALWDUMP" | i32 ggml_type | i64 ne[4]   then payload f32 (ne order, i0 fastest)
+// Runs prefill (step 0) then PALW_DUMP_STEPS greedy decode steps (step 1..N).
+#include "arg.h"
+#include "common.h"
+#include "log.h"
+#include "llama.h"
+
+#include <clocale>
+#include <cstdio>
+#include <cstring>
+#include <regex>
+#include <string>
+#include <vector>
+
+static std::string              g_dir = ".";
+static std::vector<std::regex>  g_filters;
+static int                      g_step = 0;
+
+static bool name_matches(const char * name) {
+    for (const auto & re : g_filters) {
+        if (std::regex_search(name, re)) return true;
+    }
+    return false;
+}
+
+static float get_f(const uint8_t * data, ggml_type type, const size_t * nb, size_t i0, size_t i1, size_t i2, size_t i3) {
+    size_t i = i3 * nb[3] + i2 * nb[2] + i1 * nb[1] + i0 * nb[0];
+    switch (type) {
+        case GGML_TYPE_F32: return *(const float *) &data[i];
+        case GGML_TYPE_F16: return ggml_fp16_to_fp32(*(const ggml_fp16_t *) &data[i]);
+        case GGML_TYPE_BF16: return ggml_bf16_to_fp32(*(const ggml_bf16_t *) &data[i]);
+        case GGML_TYPE_I32: return (float) *(const int32_t *) &data[i];
+        case GGML_TYPE_I64: return (float) *(const int64_t *) &data[i];
+        case GGML_TYPE_I16: return (float) *(const int16_t *) &data[i];
+        case GGML_TYPE_I8:  return (float) *(const int8_t  *) &data[i];
+        default: GGML_ABORT("unsupported type in dump");
+    }
+}
+
+static bool dump_cb(struct ggml_tensor * t, bool ask, void * user_data) {
+    (void) user_data;
+    if (ask) return name_matches(t->name);
+    if (!name_matches(t->name)) return true;
+    if (ggml_is_quantized(t->type)) return true;
+
+    std::vector<uint8_t> buf(ggml_nbytes(t));
+    ggml_backend_tensor_get(t, buf.data(), 0, buf.size());
+
+    std::string san;
+    for (const char * p = t->name; *p; ++p) {
+        san += (isalnum((unsigned char)*p) ? *p : '_');
+    }
+    char path[1024];
+    snprintf(path, sizeof(path), "%s/s%d_%s.bin", g_dir.c_str(), g_step, san.c_str());
+    // do not overwrite if the same name appears twice in one graph: append counter
+    FILE * probe = fopen(path, "rb");
+    if (probe) {
+        fclose(probe);
+        for (int c = 1; ; c++) {
+            snprintf(path, sizeof(path), "%s/s%d_%s__%d.bin", g_dir.c_str(), g_step, san.c_str(), c);
+            FILE * pr2 = fopen(path, "rb");
+            if (!pr2) break;
+            fclose(pr2);
+        }
+    }
+    FILE * f = fopen(path, "wb");
+    if (!f) { LOG_ERR("cannot open %s\n", path); return true; }
+    fwrite("PALWDUMP", 1, 8, f);
+    int32_t ty = (int32_t) t->type;
+    fwrite(&ty, 4, 1, f);
+    int64_t ne[4] = { t->ne[0], t->ne[1], t->ne[2], t->ne[3] };
+    fwrite(ne, 8, 4, f);
+    std::vector<float> out;
+    out.reserve((size_t) ne[0] * ne[1] * ne[2] * ne[3]);
+    for (int64_t i3 = 0; i3 < ne[3]; i3++)
+        for (int64_t i2 = 0; i2 < ne[2]; i2++)
+            for (int64_t i1 = 0; i1 < ne[1]; i1++)
+                for (int64_t i0 = 0; i0 < ne[0]; i0++)
+                    out.push_back(get_f(buf.data(), t->type, t->nb, i0, i1, i2, i3));
+    fwrite(out.data(), 4, out.size(), f);
+    fclose(f);
+    LOG_INF("dumped %s (%s) ne=[%lld,%lld,%lld,%lld]\n", path, ggml_type_name(t->type),
+            (long long)ne[0],(long long)ne[1],(long long)ne[2],(long long)ne[3]);
+    return true;
+}
+
+int main(int argc, char ** argv) {
+    std::setlocale(LC_NUMERIC, "C");
+    if (const char * d = getenv("PALW_DUMP_DIR")) g_dir = d;
+    std::string filt = "-(0|3)$|result_norm|result_output|model_input|input_embed";
+    if (const char * fenv = getenv("PALW_DUMP_FILTER")) filt = fenv;
+    {
+        std::string cur;
+        for (size_t i = 0; i <= filt.size(); i++) {
+            if (i == filt.size() || filt[i] == ',') {
+                if (!cur.empty()) g_filters.emplace_back(cur, std::regex::optimize);
+                cur.clear();
+            } else cur += filt[i];
+        }
+    }
+    int nsteps = 1;
+    if (const char * s = getenv("PALW_DUMP_STEPS")) nsteps = atoi(s);
+
+    common_params params;
+    common_init();
+    if (!common_params_parse(argc, argv, params, LLAMA_EXAMPLE_COMMON)) return 1;
+    llama_backend_init();
+    llama_numa_init(params.numa);
+    params.cb_eval = dump_cb;
+    params.cb_eval_user_data = nullptr;
+    params.warmup = false;
+
+    auto llama_init = common_init_from_params(params);
+    auto * model = llama_init->model();
+    auto * ctx   = llama_init->context();
+    if (!model || !ctx) { LOG_ERR("init failed\n"); return 1; }
+    const llama_vocab * vocab = llama_model_get_vocab(model);
+
+    std::vector<llama_token> tokens = common_tokenize(ctx, params.prompt, llama_vocab_get_add_bos(vocab), true);
+    LOG_INF("prompt tokens (%zu):", tokens.size());
+    for (auto t : tokens) LOG_INF(" %d", t);
+    LOG_INF("\n");
+
+    g_step = 0;
+    if (llama_decode(ctx, llama_batch_get_one(tokens.data(), tokens.size()))) { LOG_ERR("decode failed\n"); return 1; }
+
+    const int n_vocab = llama_vocab_n_tokens(vocab);
+    for (int s = 1; s <= nsteps; s++) {
+        const float * logits = llama_get_logits_ith(ctx, -1);
+        int best = 0;
+        for (int v = 1; v < n_vocab; v++) if (logits[v] > logits[best]) best = v;
+        LOG_INF("greedy step %d -> token %d\n", s, best);
+        llama_token nt = best;
+        g_step = s;
+        if (llama_decode(ctx, llama_batch_get_one(&nt, 1))) { LOG_ERR("decode failed\n"); return 1; }
+    }
+    // final greedy pick after last dumped step (printed for reference)
+    {
+        const float * logits = llama_get_logits_ith(ctx, -1);
+        int best = 0;
+        for (int v = 1; v < n_vocab; v++) if (logits[v] > logits[best]) best = v;
+        LOG_INF("next token would be %d\n", best);
+    }
+    llama_backend_free();
+    return 0;
+}
diff --git a/docs/evidence/qi35-cross-host-soak-calibration-2026-07-21.md b/docs/evidence/qi35-cross-host-soak-calibration-2026-07-21.md
new file mode 100644
index 0000000000000000000000000000000000000000..0afbf3c0b6453df8c2a2e0cd03b2ac67026ae3f2
--- /dev/null
+++ b/docs/evidence/qi35-cross-host-soak-calibration-2026-07-21.md
@@ -0,0 +1,229 @@
+# QI35 cross-host soak and fp calibration (2026-07-21)
+
+## Result
+
+The canonical-integer QI35 path passed the bounded deterministic soak on Apple
+M1 Max (`arm64`, CPU and Metal-v3) and on an independent WSL2 host (`x86_64`,
+CPU). The WSL run consumed the Mac CPU report as its independent reference.
+All scheduled token sequences and all exposed execution roots matched.
+The accepted schema-v2 reports content-address the runner, normalized backend
+plan, and complete declared non-system runtime-library set. The Mac report
+declares the one Metal DSO; `ldd` confirms that the WSL engine has only system
+runtime dependencies, matching its explicit-none declaration.
+
+The same 12-prompt, 8-token greedy corpus was then compared with a pinned
+`llama.cpp` floating-point path at revision
+`12127defda4f41b7679cb2477a4b0d65ee6a0c8f`. M1 Max Metal matched 11 of 12
+prompts completely (94 of 96 positions; the first and only divergence was
+`quick_fox` at generated-token index 6). NVIDIA RTX 4060 Ti CUDA (`sm_89`)
+matched 12 of 12 prompts and 96 of 96 positions. Each fp result was stable
+across three repetitions.
+
+The Mac result has now been recaptured with calibration schema v2, including
+the canonical Metal engine DSO and all nine non-system llama/ggml DSOs. It is
+the content-addressed reference for probe schema v2.
+
+The RTX result has also been recaptured with probe schema v2. The runner owned
+the server process, disabled HTTP proxies and redirects, verified its `/proc`
+executable, command line, model mapping, numeric-loopback listener, loader
+environment, and all 13 declared runtime DSOs against live mappings. Its
+startup log proved the pinned build, one CUDA device, and full 41/41 GPU-layer
+offload; the raw log was hashed but not stored.
+
+These are reproducible calibration and bounded-soak results, not a claim of
+semantic model quality, exhaustive hardware coverage, or production network
+readiness. In particular, RTX was measured through the floating-point CUDA
+reference path; canonical-integer CUDA was not implemented or measured.
+
+The archived RTX file named `v2` contains probe schema v1 and predates this
+runner-owned process attestation. It is retained as numerical history only; the
+accepted CUDA evidence is the schema-v2 file named `v3`.
+
+## Evidence
+
+| Report | Host/path | Outcome | SHA-256 |
+| --- | --- | --- | --- |
+| `reports/qi35-soak-mac-20260721-v2.json` | M1 Max arm64, canonical integer CPU + Metal-v3 | schema v2 PASS; 320 tokens/backend; 0 mismatches; roots equal; 1.257713 / 2.589625 tok/s; runner/backend-plan/Metal-DSO provenance | `707455328702345f43034c7dbcbb1ab7401fcadebf61c9cbd433c221dac4ae69` |
+| `reports/qi35-soak-wsl-20260721-v2.json` | WSL2 x86_64, canonical integer CPU | schema v2 PASS; 320 tokens; 0 mismatches vs exact Mac-v2 report; roots equal; 1.236333 tok/s; runner/backend-plan/explicit system-only runtime provenance | `c940720d0a14afeb88320342cb36d0829a935da6d4ba27391067136fc63c542c` |
+| `reports/qi35-calibration-mac-20260721-v2.json` | M1 Max Metal, pinned fp reference | schema v2 complete; 11/12 prompts, 94/96 positions, deterministic; canonical engine DSO plus 9 llama/ggml DSOs content-addressed | `521f1c67742ba88583f7c92b956a484e828b7643880c880d8f3a710c7ee27140` |
+| `reports/qi35-fp-probe-wsl-rtx4060ti-20260721-v3.json` | WSL2 RTX 4060 Ti sm89, pinned fp CUDA reference | probe schema v2 complete; 12/12 prompts, 96/96 positions, deterministic; runner-owned process; 13/13 live DSO bindings; 41/41 GPU layers | `17bb2fe794f64c3ff1cab7e29fbd7b8dbd322307f05f76531eb1aa0e0e7a7440` |
+
+Archived numerical reports retained for comparison:
+
+| Report | Host/path | Outcome | SHA-256 |
+| --- | --- | --- | --- |
+| `reports/qi35-soak-mac-20260721-v1.json` | M1 Max arm64, canonical integer CPU + Metal-v3 | legacy-unattested v1; numerical PASS; 320 tokens/backend; 0 mismatches; roots equal; 1.270446 / 1.817872 tok/s | `e9aaac13a82b68e7566dcc778ae5d0759c6223c0ee391c48fa6f01bffca7365e` |
+| `reports/qi35-soak-wsl-20260721-v1.json` | WSL2 x86_64, canonical integer CPU | legacy-unattested v1; numerical PASS; 320 tokens; 0 mismatches vs Mac reference; roots equal; 1.19985 tok/s | `bb66ddcf5bd6d7aeb6083db4fd833106d3e1445b59bf6bb399e3e25e8dafb2ad` |
+| `reports/qi35-calibration-mac-20260721-final.json` | M1 Max Metal, pinned fp reference | legacy-unattested calibration schema v1; numerical result complete; 11/12 prompts, 94/96 positions, deterministic | `ad4e42268691606217ddd2a355dec433e9f899fa0426260d1049c8cd3f4cf89c` |
+| `reports/qi35-fp-probe-wsl-rtx4060ti-20260721-v2.json` | WSL2 RTX 4060 Ti sm89, pinned fp CUDA reference | legacy-unattested probe schema v1; numerical result complete; 12/12 prompts, 96/96 positions, deterministic | `177826d14a2f9935f0a402200d1cfdd5521ab4ec2609350d554213eb2e4afc5b` |
+
+The two canonical-integer hosts used the same model bytes
+(`1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b`)
+and table bytes
+(`feb22fd1864a1396b9c2bc20937f3acad79bffefdefc71c50b3747da47b64c6e`).
+The schema-v2 fp reports record the patched llama source patch
+(`25f7062c3a930daf108a146f178c714c8978d92c83fa6d30af1f951705a8f62b`),
+the runners, support scripts, model, tokenizer, corpus, executable, and every
+declared non-system llama/ggml/CUDA or Metal runtime library by basename, byte
+length, and SHA-256. The probe-schema-v2 result also proves those CUDA files
+against the runner-owned process's live mappings. Reports deliberately do not
+record user names, remote addresses, private-key paths, or GPU serial/UUID
+values.
+
+## Reproduction contract
+
+Use `scripts/qi35_soak.py` for the canonical path. New output uses
+`misaka.qi35.hardware-soak.v2`; v1 reports are deliberately rejected as
+cross-host references because they have no provenance manifest. Supply two
+local backends, or one backend plus `--reference-report`, and retain the
+defaults used here:
+20 iterations, two fixed prompts, 8 generated tokens, and 2 warmups. Repeat
+`--runtime-library` for every non-system DSO, or explicitly use
+`--no-non-system-runtime-libraries` for a static/system-only engine. The report
+binds the runner, backend plan, and declared runtime libraries. The runner
+scrubs inherited `QI35_*` variables, keeps each backend alive, checks reset
+determinism, and performs a one-shot root comparison.
+
+Use `scripts/qi35_calibrate.py` when the canonical engine and fp server are on
+the same host. New output uses `misaka.qi35.fp-calibration.v2` and requires
+`--engine-library` for every canonical-engine non-system runtime DSO.
+`scripts/qi35_fp_probe.py` now launches and stops the pinned fp
+server itself; it does not accept an existing endpoint. Supply the exact server
+binary, model, loader directory, and every loaded DSO. New output uses
+`misaka.qi35.fp-cross-host-probe.v2`. On Linux/WSL it verifies the child `/proc`
+executable, command, loader environment, and memory mappings, then fails if a
+mapped DSO under the loader directory or a mapped llama/ggml/mtmd/CUDA/cuBLAS
+runtime DSO was not declared. It also requires `libggml-cuda`, a matching build
+revision, CUDA initialization, and full `N/N` GPU-layer offload in the startup
+log. `--nvidia-smi` is an explicit executable path; the runner invokes that
+resolved file with a scrubbed environment and records its content hash. HTTP
+uses numeric loopback with proxies and redirects disabled. Both runners require
+the exact llama revision and patch.
+The fp sampling contract is greedy: temperature 0, top-k 0, top-p 1, penalties
+disabled, prompt cache disabled, raw token I/O, and 8 new tokens. A report is
+invalid if attestation is incomplete, an artifact hash differs, a repetition
+is nondeterministic, or the direct loopback contract cannot be established.
+
+## Schema-v2 Mac calibration reproduction
+
+The accepted Mac calibration can be reproduced with the host-local roots
+filled into these placeholders:
+
+```sh
+QI35_ROOT=/absolute/path/to/qwen-8.0
+QI35_HARDENED=/tmp/qi35-hardened.1k3wlb
+LLAMA_BIN_DIR="$QI35_ROOT/vendor/llama.cpp/build-palw/bin"
+python3 "$QI35_ROOT/scripts/qi35_calibrate.py" \
+  --engine "$QI35_HARDENED/qi35_model" \
+  --engine-library "$QI35_HARDENED/libqi35metal.dylib" \
+  --source "$QI35_ROOT/docs/evidence/qi35_model.rs" \
+  --tables "$QI35_HARDENED/qi35_tables.bin" \
+  --model "$QI35_ROOT/models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf" \
+  --tokenizer "$QI35_ROOT/models/Qwen3.6-35B-A3B-Claude-4.7-base-meta/tokenizer.json" \
+  --corpus "$QI35_ROOT/config/qi35-calibration-prompts-v1.json" \
+  --llama-server "$LLAMA_BIN_DIR/llama-server" \
+  --llama-library "$LLAMA_BIN_DIR/libllama-server-impl.dylib" \
+  --llama-library "$LLAMA_BIN_DIR/libllama-common.0.0.10015.dylib" \
+  --llama-library "$LLAMA_BIN_DIR/libmtmd.0.0.10015.dylib" \
+  --llama-library "$LLAMA_BIN_DIR/libllama.0.0.10015.dylib" \
+  --llama-library "$LLAMA_BIN_DIR/libggml.0.16.0.dylib" \
+  --llama-library "$LLAMA_BIN_DIR/libggml-cpu.0.16.0.dylib" \
+  --llama-library "$LLAMA_BIN_DIR/libggml-blas.0.16.0.dylib" \
+  --llama-library "$LLAMA_BIN_DIR/libggml-metal.0.16.0.dylib" \
+  --llama-library "$LLAMA_BIN_DIR/libggml-base.0.16.0.dylib" \
+  --llama-revision 12127defda4f41b7679cb2477a4b0d65ee6a0c8f \
+  --llama-patch "$QI35_ROOT/patches/llama.cpp-palw-full.patch" \
+  --library-dir "$QI35_HARDENED" \
+  --output "$QI35_ROOT/docs/evidence/reports/qi35-calibration-mac-20260721-v2.json"
+```
+
+## Schema-v2 WSL CUDA probe reproduction
+
+The accepted schema-v2 CUDA report can be reproduced with the host-local roots
+filled into these placeholders. Verify the CUDA runtime paths with `ldd` on the
+target host first; every runtime-relevant live mapping must be supplied:
+
+```sh
+QI35_ROOT=/absolute/path/to/qwen-8.0
+LLAMA_BIN_DIR=/absolute/path/to/palw-llama/build-cuda/bin
+CUDA_LIB_DIR=/usr/local/cuda/targets/x86_64-linux/lib
+WSL_DRIVER_LIB_DIR=/usr/lib/wsl/lib
+python3 "$QI35_ROOT/scripts/qi35_fp_probe.py" \
+  --nvidia-smi /usr/lib/wsl/lib/nvidia-smi \
+  --server-binary "$LLAMA_BIN_DIR/llama-server" \
+  --server-library-dir "$LLAMA_BIN_DIR" \
+  --server-library "$LLAMA_BIN_DIR/libllama-server-impl.so" \
+  --server-library "$LLAMA_BIN_DIR/libllama-common.so.0" \
+  --server-library "$LLAMA_BIN_DIR/libmtmd.so.0" \
+  --server-library "$LLAMA_BIN_DIR/libllama.so.0" \
+  --server-library "$LLAMA_BIN_DIR/libggml.so.0" \
+  --server-library "$LLAMA_BIN_DIR/libggml-base.so.0" \
+  --server-library "$LLAMA_BIN_DIR/libggml-cpu.so.0" \
+  --server-library "$LLAMA_BIN_DIR/libggml-cuda.so.0" \
+  --server-library "$CUDA_LIB_DIR/libcudart.so.13" \
+  --server-library "$CUDA_LIB_DIR/libcublas.so.13" \
+  --server-library "$CUDA_LIB_DIR/libcublasLt.so.13" \
+  --server-library "$WSL_DRIVER_LIB_DIR/libcuda.so.1.1" \
+  --server-library /usr/lib/wsl/drivers/nvmdi.inf_amd64_72f1798f54a8a57a/libcuda.so.1.1 \
+  --model "$QI35_ROOT/models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf" \
+  --tokenizer "$QI35_ROOT/models/Qwen3.6-35B-A3B-Claude-4.7-base-meta/tokenizer.json" \
+  --corpus "$QI35_ROOT/config/qi35-calibration-prompts-v1.json" \
+  --llama-patch "$QI35_ROOT/patches/llama.cpp-palw-full.patch" \
+  --llama-revision 12127defda4f41b7679cb2477a4b0d65ee6a0c8f \
+  --startup-timeout 900 \
+  --reference-calibration "$QI35_ROOT/docs/evidence/reports/qi35-calibration-mac-20260721-v2.json" \
+  --output "$QI35_ROOT/docs/evidence/reports/qi35-fp-probe-wsl-rtx4060ti-20260721-v3.json"
+```
+
+## Schema-v2 soak reproduction
+
+Mac (repeat `--runtime-library` if `otool -L` shows another non-system DSO):
+
+```sh
+QI35_ROOT=/absolute/path/to/qwen-8.0
+QI35_HARDENED=/tmp/qi35-hardened.1k3wlb
+python3 "$QI35_ROOT/scripts/qi35_soak.py" \
+  --engine "$QI35_HARDENED/qi35_model" \
+  --model "$QI35_ROOT/models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf" \
+  --tables "$QI35_HARDENED/qi35_tables.bin" \
+  --source "$QI35_ROOT/docs/evidence/qi35_model.rs" \
+  --library-dir "$QI35_HARDENED" \
+  --backend cpu \
+  --backend metal-v3 \
+  --runtime-library "$QI35_HARDENED/libqi35metal.dylib" \
+  --output "$QI35_ROOT/docs/evidence/reports/qi35-soak-mac-20260721-v2.json"
+```
+
+After making the exact Mac report available in WSL, reproduce the independent
+CPU result. The captured engine's `ldd` output contains only system libraries,
+so this invocation uses the explicit-none declaration:
+
+```sh
+QI35_ROOT=/absolute/path/to/qwen-8.0
+QI35_ENGINE="$QI35_ROOT/build/qi35-hardened/qi35_model"
+QI35_MODEL="$QI35_ROOT/models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf"
+QI35_TABLES="$QI35_ROOT/build/qi35-hardened/qi35_tables.bin"
+python3 "$QI35_ROOT/scripts/qi35_soak.py" \
+  --engine "$QI35_ENGINE" \
+  --model "$QI35_MODEL" \
+  --tables "$QI35_TABLES" \
+  --source "$QI35_ROOT/docs/evidence/qi35_model.rs" \
+  --backend cpu \
+  --reference-report "$QI35_ROOT/docs/evidence/reports/qi35-soak-mac-20260721-v2.json" \
+  --no-non-system-runtime-libraries \
+  --output "$QI35_ROOT/docs/evidence/reports/qi35-soak-wsl-20260721-v2.json"
+```
+
+## Supported and open scope
+
+- Provenance-backed bounded canonical path: M1 Max arm64 CPU/Metal-v3 and WSL2
+  x86_64 CPU for this exact model, table set, source, corpus, runner, backend
+  plan, runtime-library declaration, and schedule.
+- Provenance-backed bounded fp calibration: M1 Max Metal and an independently
+  attested RTX 4060 Ti sm89 probe with the pinned patched llama revision.
+- Not yet evidenced: canonical-integer CUDA, NVIDIA Turing or other CUDA
+  generations, longer contexts, sampling/non-greedy decoding, multi-session
+  load, thermal throttling over multi-hour runs, crash recovery, and other
+  model/table revisions.
+- A production support claim requires a larger adversarial corpus, longer
+  duration, per-device calibration thresholds, and deployment monitoring.
diff --git a/docs/evidence/qi35_chat.py b/docs/evidence/qi35_chat.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3accb451adf520dee3d80925e6a7dd57b2cb2da
--- /dev/null
+++ b/docs/evidence/qi35_chat.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+# QI35 interactive chat over the canonical-INTEGER Qwen3.6-35B-A3B engine (qi35_model --serve).
+# Deterministic, vendor-independent integer forward. Each answer self-issues a canonical_integer_v0
+# receipt (keyed-BLAKE2b MAC over prompt/output commitments + model/engine/tables hashes).
+#
+#   REPL : python3 qi35_chat.py
+#   one  : python3 qi35_chat.py "What is the capital of France?"
+import sys, os, json, subprocess, threading, hashlib
+from tokenizers import Tokenizer
+
+MODEL   = os.environ["QI35_MODEL"]         # gguf path
+TABLES  = os.environ["QI35_TABLES"]        # qi35_tables.bin
+ENGINE  = os.environ["QI35_ENGINE"]        # qi35_model binary
+TOKJSON = os.environ["QI35_TOKENIZER"]     # tokenizer.json
+AKEY    = os.environ.get("QI35_AUDIT_KEY", "")   # 32-byte raw audit key file (optional)
+RCPTDIR = os.environ.get("QI35_RECEIPT_DIR", "")
+MAXNEW  = int(os.environ.get("QI35_MAX_NEW", "200"))
+THREADS = os.environ.get("QI35_THREADS", "8")
+SYS     = os.environ.get("QI35_SYSTEM", "You are a concise, helpful assistant.")
+EOS     = 248046  # <|im_end|>
+
+tok = Tokenizer.from_file(TOKJSON)
+
+def build_prompt_ids(history, user):
+    s = f"<|im_start|>system\n{SYS}<|im_end|>\n"
+    for u, a in history:
+        s += f"<|im_start|>user\n{u}<|im_end|>\n<|im_start|>assistant\n{a}<|im_end|>\n"
+    s += f"<|im_start|>user\n{user}<|im_end|>\n<|im_start|>assistant\n"
+    return tok.encode(s, add_special_tokens=False).ids
+
+class Engine:
+    def __init__(self):
+        cmd = [ENGINE, MODEL, TABLES, "--serve", "--threads", THREADS,
+               "--max-new", str(MAXNEW), "--eos", str(EOS)]
+        if os.environ.get("QI35_METAL"):
+            cmd.append("--metal")
+        if AKEY:
+            cmd += ["--audit-key-file", AKEY]
+        self.p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE, text=True, bufsize=1)
+        # surface stderr (model load / hashing progress) live
+        def pump():
+            for ln in self.p.stderr:
+                sys.stderr.write("  [engine] " + ln)
+        threading.Thread(target=pump, daemon=True).start()
+        # wait for SERVE_READY on stdout
+        for ln in self.p.stdout:
+            if ln.strip() == "SERVE_READY":
+                break
+
+    def ask(self, prompt_ids):
+        self.p.stdin.write(",".join(map(str, prompt_ids)) + "\n")
+        self.p.stdin.flush()
+        gen, rcpt, done = [], None, None
+        for ln in self.p.stdout:
+            ln = ln.rstrip("\n")
+            if ln.startswith("GEN "):
+                gen = [int(x) for x in ln[4:].split(",") if x]
+            elif ln.startswith("RCPT "):
+                rcpt = json.loads(ln[5:])
+            elif ln.startswith("DONE "):
+                done = ln[5:]; break
+            elif ln.startswith("ERR "):
+                done = ln; break
+        return gen, rcpt, done
+
+def verify_receipt(rcpt, akey_bytes):
+    # recompute prompt/output commitments would require the ids; here we just re-check the MAC
+    # binds the published commitments (integrity of the receipt record itself).
+    def dom(t): return len(t).to_bytes(8, "little") + t.encode()
+    nid = bytes.fromhex(rcpt["network_id"])
+    mb  = dom("qi35-receipt/v0") + nid
+    mb += bytes.fromhex(rcpt["model_blake2b256"]) + bytes.fromhex(rcpt["engine_blake2b256"]) + bytes.fromhex(rcpt["tables_blake2b256"])
+    mb += dom(rcpt["ruleset_id"])
+    mb += rcpt["prompt_tokens"].to_bytes(8, "little") + rcpt["output_tokens"].to_bytes(8, "little")
+    mb += bytes.fromhex(rcpt["prompt_commitment"]) + bytes.fromhex(rcpt["output_commitment"])
+    mb += bytes([1 if rcpt["eos_reached"] else 0]) + int(rcpt["timestamp_millis"]).to_bytes(8, "little")
+    mac = hashlib.blake2b(mb, digest_size=32, key=akey_bytes).hexdigest()
+    return mac == rcpt["mac"]
+
+def answer(engine, history, user, akey_bytes, turn):
+    ids = build_prompt_ids(history, user)
+    gen, rcpt, done = engine.ask(ids)
+    text = tok.decode(gen, skip_special_tokens=True).strip()
+    info = ""
+    if rcpt:
+        ok = verify_receipt(rcpt, akey_bytes) if akey_bytes else None
+        oc = rcpt["output_commitment"]
+        if RCPTDIR:
+            os.makedirs(RCPTDIR, exist_ok=True)
+            base = os.path.join(RCPTDIR, f"turn{turn:03d}-{oc[:16]}")
+            json.dump(rcpt, open(base + ".receipt.json", "w"), indent=2)
+            # opening (private): the prompt+output ids needed to independently re-verify
+            json.dump({"prompt_ids": ids, "output_ids": gen}, open(base + ".opening.json", "w"))
+        info = f"\n  [receipt canonical_integer_v0  out_commit={oc[:16]}…  MAC={'OK' if ok else ('n/a' if ok is None else 'BAD')}  {done}]"
+    else:
+        info = f"\n  [{done}]"
+    return text, info
+
+def main():
+    akey_bytes = open(AKEY, "rb").read() if AKEY else b""
+    engine = Engine()
+    if len(sys.argv) > 1:
+        q = " ".join(sys.argv[1:])
+        text, info = answer(engine, [], q, akey_bytes, 0)
+        print(f"Q: {q}\nA: {text}{info}")
+        return
+    print("Qwen3.6-35B — canonical-INTEGER 版 (決定的・vendor 非依存)。自家発行 receipt 付き。")
+    print("質問を入力。空行 or /quit で終了。/reset で履歴クリア。\n")
+    hist, turn = [], 0
+    while True:
+        try:
+            q = input("あなた> ").strip()
+        except EOFError:
+            break
+        if not q or q == "/quit":
+            break
+        if q == "/reset":
+            hist = []; print("(履歴クリア)\n"); continue
+        turn += 1
+        text, info = answer(engine, hist, q, akey_bytes, turn)
+        print(f"Qwen> {text}{info}\n")
+        hist.append((q, text))
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/evidence/qi35_chat.sh b/docs/evidence/qi35_chat.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b5d0652d6fdd01fa02b58844707f6312b9ee2e1c
--- /dev/null
+++ b/docs/evidence/qi35_chat.sh
@@ -0,0 +1,16 @@
+#!/bin/zsh
+# QI35 canonical-integer Qwen3.6-35B chat launcher (deterministic, vendor-independent, receipt-issuing).
+#   ./qi35_chat.sh                         # REPL
+#   ./qi35_chat.sh "What is the capital of France?"   # one-shot
+SP="$(cd "$(dirname "$0")" && pwd)"
+WS="${QI35_WORKSPACE:-$(cd "$SP/../.." && pwd)}"
+export QI35_MODEL="${QI35_MODEL:-$WS/models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf}"
+export QI35_TABLES="$SP/qi35_tables.bin"
+export QI35_ENGINE="$SP/qi35_model"
+export QI35_TOKENIZER="${QI35_TOKENIZER:-$WS/models/Qwen3.6-35B-A3B-Claude-4.7-base-meta/tokenizer.json}"
+export QI35_AUDIT_KEY="${QI35_AUDIT_KEY:-$SP/palw-audit.key}"
+export QI35_RECEIPT_DIR="${QI35_RECEIPT_DIR:-$SP/chat-receipts}"
+export QI35_MAX_NEW="${QI35_MAX_NEW:-200}"
+export QI35_THREADS="${QI35_THREADS:-8}"
+QI35_PYTHON="${QI35_PYTHON:-python3}"
+exec "$QI35_PYTHON" "$SP/qi35_chat.py" "$@"
diff --git a/docs/evidence/qi35_export_tables.py b/docs/evidence/qi35_export_tables.py
new file mode 100644
index 0000000000000000000000000000000000000000..245c230e5aa3f5a6d53f6a00b56f8b180c204374
--- /dev/null
+++ b/docs/evidence/qi35_export_tables.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+# Export the pinned QI35 LUT/RoPE tables as a byte artifact (qi35_tables.bin).
+# Layout (all i64 LE):  "QI35TBL1" | SMAX u32 | pad u32 |
+#   SIG[16384] | SOFTPLUS[16384] | EXPN[16384] | GAMMA[32769] | COS[SMAX*32] | SIN[SMAX*32]
+import struct, hashlib, math
+import numpy as np
+
+SMAX = 8192
+SIG = np.clip(np.rint(1.0 / (1.0 + np.exp(-(np.arange(16384) - 8192) / 512.0)) * (1 << 16)), 0, 1 << 16).astype(np.int64)
+SOFTPLUS = np.rint(np.log1p(np.exp((np.arange(16384) - 8192) / 512.0)) * (1 << 16)).astype(np.int64)
+EXPN = np.clip(np.rint(np.exp(-np.arange(16384) / 2048.0) * (1 << 20)), 0, 1 << 20).astype(np.int64)
+GAMMA = np.clip(np.rint(np.exp(-np.arange(32769) / 2048.0) * (1 << 30)), 0, 1 << 30).astype(np.int64)
+k = np.arange(32)
+inv = (10000000.0) ** (-2.0 * k / 64)
+ang = np.outer(np.arange(SMAX), inv)
+COS = np.rint(np.cos(ang) * (1 << 30)).astype(np.int64).reshape(-1)
+SIN = np.rint(np.sin(ang) * (1 << 30)).astype(np.int64).reshape(-1)
+
+out = bytearray(b"QI35TBL1")
+out += struct.pack("<II", SMAX, 0)
+for arr in (SIG, SOFTPLUS, EXPN, GAMMA, COS, SIN):
+    out += arr.tobytes()
+open("qi35_tables.bin", "wb").write(bytes(out))
+print(f"qi35_tables.bin: {len(out):,} bytes blake2b16={hashlib.blake2b(bytes(out), digest_size=16).hexdigest()}")
diff --git a/docs/evidence/qi35_int_ref.py b/docs/evidence/qi35_int_ref.py
new file mode 100644
index 0000000000000000000000000000000000000000..a263b932b47bf021735bbb171d94bea96843829f
--- /dev/null
+++ b/docs/evidence/qi35_int_ref.py
@@ -0,0 +1,724 @@
+#!/usr/bin/env python3
+# QI35-3: exact-integer reference for Qwen3.6-35B-A3B canonical forward (layers 0 & 3 + MoE),
+# consuming the production Q4_K_M GGUF directly (no requantization), compared checkpoint-by-checkpoint
+# against fp32 activations dumped from llama.cpp CPU (palw_fp_dump).
+#
+# Integer semantics per docs/canonical-integer-qwen36-design.md:
+#   scales Q60 (SC=60), activations A24 per-token, weights = exact Q4_K/Q6_K rational algebra,
+#   DeltaNet inner path: conv/v Q16, q/k unit Q20, beta/softplus Q16, gamma Q24, state Q24 (i64-safe),
+#   LUTs: SIG 16384x(1/512) Q16, SOFTPLUS 16384x(1/512) Q16, EXPNEG 4096x(1/512) domain [0,8) Q16
+#   (extended from the 0.5B 2048-entry table because 35B router deltas reach ~7.2), GAMMA-EXP 4096x(1/512)
+#   domain [-8,0] Q24, RoPE cos/sin Q30 (64 dims), INV_SQRT128 Q30.
+import math
+import os
+import struct
+import sys
+from pathlib import Path
+import numpy as np
+
+WORKSPACE = Path(os.environ.get("QI35_WORKSPACE", Path(__file__).resolve().parents[2]))
+GGUF = os.environ.get(
+    "QI35_MODEL",
+    WORKSPACE / "models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+)
+DUMP = sys.argv[1] if len(sys.argv) > 1 else "fpdump"
+
+SC = 60; HALF = 1 << (SC - 1); ALVL = (1 << 23) - 1
+D = 2048; NL = 40
+# DeltaNet
+HK, HV, SDIM = 16, 32, 128           # k-heads, v-heads, head dim (state 128x128 per v-head)
+CONVK = 4
+# attention
+NH, NKV, HD, NROT = 16, 2, 256, 64
+# MoE
+NEXP, TOPK, FEXP = 256, 8, 512
+
+def rne(a, s):  # round-half-up shift (hifi idiom), works for negative a via arithmetic shift
+    return (a + (1 << (s - 1))) >> s
+def qmf(m0, sh):
+    e = sh - 31 + SC
+    return (m0 << e) if e >= 0 else rne(m0, -e)
+def q60(m, e):  # Q60 representation of m * 2^e  (m python int >= 0)
+    if e + SC >= 0: return m << (e + SC)
+    return rne(m, -(e + SC))
+def apply(a, s): return (a * s + HALF) >> SC
+def mul(a, b): return (a * b + HALF) >> SC
+def sfrom(amax, cur): return (amax * cur) // ALVL
+def fdiv(a, b):
+    q, r = divmod(a, b)
+    return q
+def isqrt(n): return math.isqrt(n) if n > 0 else 0
+
+def aq_rows(v, cur):
+    # per-token (row-wise) A24 quantization. v: [S, N] int array (object ok) -> q int64, scales list
+    S = v.shape[0]
+    qs = np.empty(v.shape, np.int64); sc = []
+    for s in range(S):
+        row = v[s]
+        amax = int(np.max(np.abs(row))) or 1
+        ro = row.astype(object)
+        qs[s] = ((ro * ALVL * 2 + np.sign(ro) * amax) // (2 * amax)).astype(np.int64)
+        sc.append(sfrom(amax, cur[s] if isinstance(cur, list) else cur))
+    return qs, sc
+
+# ---------------- LUTs (pinned) ----------------
+SIG = np.clip(np.rint(1.0 / (1.0 + np.exp(-(np.arange(16384) - 8192) / 512.0)) * (1 << 16)), 0, 1 << 16).astype(np.int64)
+SOFTPLUS = np.rint(np.log1p(np.exp((np.arange(16384) - 8192) / 512.0)) * (1 << 16)).astype(np.int64)
+EXPN = np.clip(np.rint(np.exp(-np.arange(16384) / 2048.0) * (1 << 20)), 0, 1 << 20).astype(np.int64)   # [0,8) step 1/2048, Q20
+GAMMA = np.clip(np.rint(np.exp(-np.arange(32769) / 2048.0) * (1 << 30)), 0, 1 << 30).astype(np.int64)  # [-16,0] step 1/2048, Q30
+INV_SQRT128_Q30 = int(np.rint((1 << 30) / math.sqrt(128)))
+INV16_Q60 = (1 << 60) // 16  # attention 1/sqrt(256) = 1/16 exact
+
+def rope_tables(smax):
+    k = np.arange(NROT // 2)
+    inv = (10000000.0) ** (-2.0 * k / NROT)
+    ang = np.outer(np.arange(smax), inv)
+    return (np.rint(np.cos(ang) * (1 << 30)).astype(np.int64),
+            np.rint(np.sin(ang) * (1 << 30)).astype(np.int64))
+
+# ---------------- GGUF ----------------
+GGML_SIZES = {0: ("F32", 1, 4), 1: ("F16", 1, 2), 12: ("Q4_K", 256, 144), 14: ("Q6_K", 256, 210)}
+def load_gguf_dir(path):
+    f = open(path, "rb")
+    assert f.read(4) == b"GGUF"
+    ver, tcount, kvcount = struct.unpack("<IQQ", f.read(20))
+    def rd_str():
+        n = struct.unpack("<Q", f.read(8))[0]; return f.read(n).decode()
+    align = 32
+    def rd_val(vt):
+        nonlocal align
+        if vt == 8: return rd_str()
+        fmt = {0:"B",1:"b",2:"H",3:"h",4:"I",5:"i",6:"f",7:"B",10:"Q",11:"q",12:"d"}[vt] if vt != 9 else None
+        if vt != 9:
+            return struct.unpack("<"+fmt, f.read(struct.calcsize(fmt)))[0]
+        et, cnt = struct.unpack("<IQ", f.read(12))
+        for _ in range(cnt): rd_val(et)
+        return None
+    for _ in range(kvcount):
+        key = rd_str(); vt = struct.unpack("<I", f.read(4))[0]
+        v = rd_val(vt)
+        if key == "general.alignment": align = v
+    dirn = {}
+    for _ in range(tcount):
+        name = rd_str()
+        nd = struct.unpack("<I", f.read(4))[0]
+        ne = struct.unpack(f"<{nd}q", f.read(8 * nd))
+        ty, off = struct.unpack("<IQ", f.read(12))
+        dirn[name] = (list(ne), ty, off)
+    pos = f.tell()
+    base = (pos + align - 1) // align * align
+    f.close()
+    return dirn, base
+
+DIR, DATA_BASE = load_gguf_dir(GGUF)
+MM = np.memmap(GGUF, np.uint8, "r")
+
+def tget(name, off, nbytes):
+    ne, ty, toff = DIR[name]
+    return np.asarray(MM[DATA_BASE + toff + off: DATA_BASE + toff + off + nbytes])
+
+# fp16/fp32 exact (mant, e) with value = mant * 2^e (mant signed int)
+def f16_me(bits):
+    s = (bits >> 15) & 1; e5 = (bits >> 10) & 31; fr = bits & 1023
+    assert e5 != 31
+    if e5 == 0: m, e = int(fr), -24
+    else: m, e = int(1024 + fr), int(e5) - 25
+    return (-m if s else m), e
+def f32_me(bits):
+    s = (bits >> 31) & 1; e8 = (bits >> 23) & 255; fr = bits & 0x7FFFFF
+    assert e8 != 255
+    if e8 == 0: m, e = int(fr), -149
+    else: m, e = int((1 << 23) + fr), int(e8) - 150
+    return (-m if s else m), e
+
+def load_f32_qfix(name, Q):
+    # F32/F16 tensor -> pinned integer at 2^-Q (RNE, exact from bits)
+    ne, ty, off = DIR[name]
+    n = int(np.prod(ne))
+    if ty == 0:
+        bits = tget(name, 0, n * 4).view(np.uint32)
+    else:
+        bits = tget(name, 0, n * 2).view(np.uint16).astype(np.uint32)
+    out = np.empty(n, object)
+    for i in range(n):
+        m, e = (f32_me(int(bits[i])) if ty == 0 else f16_me(int(bits[i])))
+        ee = e + Q
+        out[i] = (m << ee) if ee >= 0 else rne(m, -ee)
+    return out.reshape(ne[::-1]) if len(ne) > 1 else out   # row-major [ne1, ne0]
+
+# ---------------- Q4_K / Q6_K decode ----------------
+Q4CACHE = {}
+def q4k_decode(name, row0, rows):
+    # returns q[rows, k] uint8, and per-superblock: dmant,de,dminmant,dmine [rows,nsb], sc,mn [rows,nsb,8]
+    key = (name, row0, rows)
+    if key in Q4CACHE: return Q4CACHE[key]
+    ne, ty, off = DIR[name]; assert ty == 12
+    k = ne[0]; nsb = k // 256
+    raw = tget(name, row0 * nsb * 144, rows * nsb * 144).reshape(rows, nsb, 144)
+    d16 = raw[:, :, 0:2].copy().view(np.uint16)[:, :, 0]
+    dm16 = raw[:, :, 2:4].copy().view(np.uint16)[:, :, 0]
+    scl = raw[:, :, 4:16]
+    qs = raw[:, :, 16:144]
+    sc = np.empty((rows, nsb, 8), np.int64); mn = np.empty((rows, nsb, 8), np.int64)
+    for j in range(8):
+        if j < 4:
+            sc[:, :, j] = scl[:, :, j] & 63
+            mn[:, :, j] = scl[:, :, j + 4] & 63
+        else:
+            sc[:, :, j] = (scl[:, :, j + 4] & 0xF) | ((scl[:, :, j - 4] >> 6) << 4)
+            mn[:, :, j] = (scl[:, :, j + 4] >> 4) | ((scl[:, :, j] >> 6) << 4)
+    q = np.empty((rows, nsb, 256), np.uint8)
+    for c in range(4):  # 64-value chunks: q bytes 32*c..32*c+32
+        blk = qs[:, :, 32 * c:32 * (c + 1)]
+        q[:, :, 64 * c:64 * c + 32] = blk & 0xF
+        q[:, :, 64 * c + 32:64 * c + 64] = blk >> 4
+    dmant = np.empty((rows, nsb), np.int64); de = np.empty((rows, nsb), np.int64)
+    mmant = np.empty((rows, nsb), np.int64); me = np.empty((rows, nsb), np.int64)
+    for r in range(rows):
+        for b in range(nsb):
+            m1, e1 = f16_me(int(d16[r, b])); dmant[r, b] = m1; de[r, b] = e1
+            m2, e2 = f16_me(int(dm16[r, b])); mmant[r, b] = m2; me[r, b] = e2
+    out = (q.reshape(rows, k), dmant, de, mmant, me, sc, mn)
+    if rows <= 8192: Q4CACHE[key] = out
+    return out
+
+Q6CACHE = {}
+def q6k_decode(name, row0, rows):
+    key = (name, row0, rows)
+    if key in Q6CACHE: return Q6CACHE[key]
+    ne, ty, off = DIR[name]; assert ty == 14
+    k = ne[0]; nsb = k // 256
+    raw = tget(name, row0 * nsb * 210, rows * nsb * 210).reshape(rows, nsb, 210)
+    ql = raw[:, :, 0:128]; qh = raw[:, :, 128:192]
+    scs = raw[:, :, 192:208].copy().view(np.int8)
+    d16 = raw[:, :, 208:210].copy().view(np.uint16)[:, :, 0]
+    q = np.empty((rows, nsb, 256), np.int64)
+    for half in range(2):  # n = 128*half
+        qlh = ql[:, :, 64 * half:64 * half + 64]; qhh = qh[:, :, 32 * half:32 * half + 32]
+        base = 128 * half
+        q[:, :, base + 0:base + 32] = ((qlh[:, :, 0:32] & 0xF) | (((qhh >> 0) & 3) << 4)).astype(np.int64) - 32
+        q[:, :, base + 32:base + 64] = ((qlh[:, :, 32:64] & 0xF) | (((qhh >> 2) & 3) << 4)).astype(np.int64) - 32
+        q[:, :, base + 64:base + 96] = ((qlh[:, :, 0:32] >> 4) | (((qhh >> 4) & 3) << 4)).astype(np.int64) - 32
+        q[:, :, base + 96:base + 128] = ((qlh[:, :, 32:64] >> 4) | (((qhh >> 6) & 3) << 4)).astype(np.int64) - 32
+    dmant = np.empty((rows, nsb), np.int64); de = np.empty((rows, nsb), np.int64)
+    for r in range(rows):
+        for b in range(nsb):
+            m1, e1 = f16_me(int(d16[r, b])); dmant[r, b] = m1; de[r, b] = e1
+    out = (q.reshape(rows, k), dmant, de, scs)
+    if rows <= 8192: Q6CACHE[key] = out
+    return out
+
+def gemm_q4k(name, x_int, row0=0, rows=None):
+    # exact: returns (acc list of python ints, emin list) for each output row; x_int [k] int64 (A24)
+    ne, _, _ = DIR[name]; k = ne[0]
+    if rows is None: rows = ne[1]
+    q, dmant, de, mmant, me, sc, mn = q4k_decode(name, row0, rows)
+    nsb = k // 256
+    xr = x_int.reshape(nsb, 8, 32)
+    qr = q.reshape(rows, nsb, 8, 32).astype(np.int64)
+    dots = np.einsum('rbjl,bjl->rbj', qr, xr, dtype=np.int64)          # <= 2^32.3
+    sums = xr.sum(2)                                                    # [nsb, 8]
+    A = dmant * np.einsum('rbj,rbj->rb', sc, dots)                      # <= 2^55 (int64 ok)
+    B = mmant * (mn * sums[None, :, :]).sum(2)
+    accs = []; emins = []
+    Ao = A.astype(object); Bo = B.astype(object)
+    for r in range(rows):
+        emin = int(min(de[r].min(), me[r].min()))
+        t = 0
+        for b in range(nsb):
+            t += int(Ao[r, b]) << int(de[r, b] - emin)
+            t -= int(Bo[r, b]) << int(me[r, b] - emin)
+        accs.append(t); emins.append(emin)
+    return accs, emins
+
+def gemm_q6k(name, x_int, row0=0, rows=None):
+    ne, _, _ = DIR[name]; k = ne[0]
+    if rows is None: rows = ne[1]
+    q, dmant, de, scs = q6k_decode(name, row0, rows)
+    nsb = k // 256
+    xr = x_int.reshape(nsb, 16, 16)
+    qr = q.reshape(rows, nsb, 16, 16)
+    dots = np.einsum('rbjl,bjl->rbj', qr, xr, dtype=np.int64)
+    A = dmant * np.einsum('rbj,rbj->rb', scs.astype(np.int64), dots)
+    accs = []; emins = []
+    Ao = A.astype(object)
+    for r in range(rows):
+        emin = int(de[r].min())
+        t = 0
+        for b in range(nsb):
+            t += int(Ao[r, b]) << int(de[r, b] - emin)
+        accs.append(t); emins.append(emin)
+    return accs, emins
+
+def proj(name, x_q, s_x, row0=0, rows=None):
+    # hifi-style: exact GEMM -> per-row Q60 col scales -> common cmax -> A24 per token.
+    # x_q: [S, k]; returns q [S, rows], scales per token (list)
+    ne, ty, _ = DIR[name]
+    S = x_q.shape[0]
+    if rows is None: rows = ne[1] if len(ne) > 1 else 1
+    out = np.empty((S, rows), object); outsc = []
+    for s in range(S):
+        accs, emins = (gemm_q4k if ty == 12 else gemm_q6k)(name, x_q[s], row0, rows)
+        colsq = [mul(s_x[s], q60(1, emins[o])) for o in range(rows)]
+        cmax = max(colsq)
+        if cmax == 0: cmax = 1
+        for o in range(rows):
+            ratio = (colsq[o] << SC) // cmax
+            out[s, o] = apply(accs[o], ratio)
+        outsc.append(cmax)
+    q, sc = aq_rows(out, outsc)
+    return q, sc
+
+# ---------------- norms ----------------
+EPS_Q40 = 1099512  # RNE(1e-6 * 2^40): rms_norm_eps pinned
+
+def rms_q(hq, s_h, gname, gQ30, out_corr=None):
+    # hq: [S, N] A24-ish ints with per-token Q60 scale s_h (scale cancels in normalization).
+    # returns per-token A24 q + Q60 scales.   yg = h*inv*gamma_q30 ; inv = isqrt(2^88/(mean+eps))
+    # eps in int^2 units: real eps 1e-6 -> eps_int = EPS_Q40 * U^2 >> 40, U = 2^60/s_h (int units per 1.0 real)
+    S, N = hq.shape
+    yg = np.empty((S, N), object)
+    for s in range(S):
+        row = hq[s].astype(object)
+        ss = int((row * row).sum())
+        U = (1 << 60) // int(s_h[s] if isinstance(s_h, list) else s_h)
+        eps_int = (EPS_Q40 * U * U) >> 40
+        mean = ss // N + eps_int + 1
+        inv = isqrt((1 << 88) // mean)
+        yg[s] = np.array([rne(int(v), 30) for v in (row * inv * gQ30)], dtype=object)
+    q, s0 = aq_rows(yg, 1 << SC)
+    # products pre-normalized by RNE>>30 (i128-implementability, pinned); scale corr 74-30=44
+    return q, [rne(x, 44) for x in s0]
+
+EPS_Q48 = 281474977  # RNE(1e-6 * 2^48): eps for Q24 fixed-point per-head norms (mean units Q48)
+
+def rms_perhead(vals_obj, gQ30, N):
+    # vals_obj: [N] object ints in Q24 fixed point (mean units 2^-48)
+    ss = int(sum(int(v) * int(v) for v in vals_obj))
+    mean = ss // N + EPS_Q48 + 1
+    inv = isqrt((1 << 88) // mean)
+    return [rne(int(v) * inv * int(g), 30) for v, g in zip(vals_obj, gQ30)]  # scale 2^-44 rel. to unit
+
+# ---------------- comparisons ----------------
+def load_dump(name):
+    with open(f"{DUMP}/{name}.bin", "rb") as f:
+        assert f.read(8) == b"PALWDUMP"
+        ty = struct.unpack("<i", f.read(4))[0]
+        ne = struct.unpack("<4q", f.read(32))
+        d = np.frombuffer(f.read(), np.float32)
+    return d.reshape([x for x in ne[::-1] if True]).squeeze(), ne
+
+REPORT = []
+def cmp(tag, mine, ref):
+    mine = np.asarray(mine, np.float64).reshape(-1); ref = np.asarray(ref, np.float64).reshape(-1)
+    assert mine.size == ref.size, f"{tag}: {mine.size} vs {ref.size}"
+    scale = np.max(np.abs(ref)) or 1.0
+    err = np.max(np.abs(mine - ref)) / scale
+    rmse = np.sqrt(np.mean((mine - ref) ** 2)) / scale
+    REPORT.append((tag, err, rmse, scale))
+    print(f"  {tag:36s} relmax={err:10.3e} relrmse={rmse:10.3e} (refmax {scale:.4g})")
+
+def toreal(q, s):  # A24 int + Q60 scale -> float
+    return np.array([float(int(v)) for v in np.asarray(q).reshape(-1)]).reshape(np.asarray(q).shape) * (s / 2**60 if not isinstance(s, list) else 1.0)
+
+def rows_real(q, scs):
+    out = np.empty(q.shape, np.float64)
+    for s in range(q.shape[0]): out[s] = q[s].astype(np.float64) * (float(scs[s]) / 2**60)
+    return out
+
+# ================= forward =================
+TOKS_S0 = [9419, 11, 1814]
+TOK_S1 = [0]
+
+def shq(a, s, outq):  # (A24 int, Q60 scale) -> absolute Q{outq} fixed point, RNE
+    return rne(int(a) * int(s), 60 + 24 - outq - 24 + 24) if False else (int(a) * int(s) + (1 << (60 + 23 - outq))) >> (60 + 24 - outq) if False else rne(int(a) * int(s), 120 - 60 - outq + 60 - 60)  # placeholder
+def to_fix(a, s, outq):
+    # real = a*s/2^60 ; want RNE(real * 2^outq) = RNE(a*s / 2^(60-outq))
+    sh = 60 - outq
+    return rne(int(a) * int(s), sh)
+
+def embed_tokens(toks):
+    name = "token_embd.weight"
+    hq = None; hs = []
+    rowsq = []
+    for t in toks:
+        q, dmant, de, mmant, me, sc, mn = q4k_decode(name, t, 1)
+        k = q.shape[1]; nsb = k // 256
+        emin = int(min(de[0].min(), me[0].min()))
+        vals = np.empty(k, object)
+        for b in range(nsb):
+            for j in range(8):
+                dpart = int(dmant[0, b]) * int(sc[0, b, j])
+                mpart = int(mmant[0, b]) * int(mn[0, b, j])
+                for l in range(32):
+                    i = b * 256 + j * 32 + l
+                    vals[i] = (dpart * int(q[0, i]) << int(de[0, b] - emin)) - (mpart << int(me[0, b] - emin))
+        rowsq.append((vals, emin))
+    S = len(toks)
+    out = np.empty((S, D), object); curs = []
+    for s, (vals, emin) in enumerate(rowsq):
+        out[s] = vals; curs.append(q60(1, emin))
+    q, scs = aq_rows(out, curs)
+    return q, scs
+
+GAM0 = load_f32_qfix("blk.0.attn_norm.weight", 30)
+GAM0P = load_f32_qfix("blk.0.post_attention_norm.weight", 30)
+SSM_NORM0 = load_f32_qfix("blk.0.ssm_norm.weight", 30)
+SSM_DT0 = load_f32_qfix("blk.0.ssm_dt", 16)
+SSM_A0 = load_f32_qfix("blk.0.ssm_a", 30)
+CONVW0 = load_f32_qfix("blk.0.ssm_conv1d.weight", 30)   # [8192, 4]
+
+def sig_idx(xq16):  # Q16 -> table idx (1/512 step), clamp
+    i = rne(int(xq16), 7) + 8192
+    return 0 if i < 0 else (16383 if i > 16383 else i)
+
+def silu_q16(xq16):
+    return (int(xq16) * int(SIG[sig_idx(xq16)])) >> 16
+
+def deltanet_layer0(h_q, h_s, S, conv_state, dstate, t0):
+    x_q, x_s = rms_q(h_q, h_s, "blk.0.attn_norm.weight", GAM0)
+    cmp(f"s{t0}_attn_norm_0", rows_real(x_q, x_s), load_dump(f"s{t0}_attn_norm_0")[0])
+    qkv_q, qkv_s = proj("blk.0.attn_qkv.weight", x_q, x_s)
+    cmp(f"s{t0}_qkv_mixed", rows_real(qkv_q, qkv_s), load_dump(f"s{t0}_linear_attn_qkv_mixed_0")[0])
+    z_q, z_s = proj("blk.0.attn_gate.weight", x_q, x_s)
+    cmp(f"s{t0}_z", rows_real(z_q, z_s), load_dump(f"s{t0}_z_0")[0])
+    bq, bs = proj("blk.0.ssm_beta.weight", x_q, x_s)
+    aq_, as_ = proj("blk.0.ssm_alpha.weight", x_q, x_s)
+    cmp(f"s{t0}_alpha", rows_real(aq_, as_), load_dump(f"s{t0}_alpha_0")[0])
+    # per token scalars
+    beta16 = np.empty((S, HV), np.int64); gam24 = np.empty((S, HV), np.int64)
+    spl_chk = np.empty((S, HV), np.float64); g_chk = np.empty((S, HV), np.float64)
+    for s in range(S):
+        for h in range(HV):
+            b16 = to_fix(bq[s, h], bs[s], 16)
+            beta16[s, h] = SIG[sig_idx(b16)]
+            a16 = to_fix(aq_[s, h], as_[s], 16) + int(SSM_DT0[h])
+            spl = int(SOFTPLUS[sig_idx(a16)]) if a16 < (20 << 16) else int(a16)
+            spl_chk[s, h] = spl / 2**16
+            gprod = int(SSM_A0[h]) * spl          # Q46 (negative)
+            g_chk[s, h] = gprod / 2**46
+            gidx = rne(-gprod, 35)                 # 1/2048 units of -g
+            gam24[s, h] = GAMMA[gidx] if gidx <= 32768 else 0
+    cmp(f"s{t0}_beta_sigmoid", beta16.astype(np.float64) / 2**16, load_dump(f"s{t0}_beta_sigmoid_0")[0])
+    cmp(f"s{t0}_a_softplus", spl_chk, load_dump(f"s{t0}_a_softplus_0")[0])
+    cmp(f"s{t0}_gate_g", g_chk, load_dump(f"s{t0}_gate_0")[0])
+    # conv (Q16 ring) + silu
+    conv_out = np.empty((S, 8192), np.int64)
+    for s in range(S):
+        u = np.array([to_fix(qkv_q[s, c], qkv_s[s], 16) for c in range(8192)], np.int64)
+        win = conv_state + [u]     # 4 entries [8192]
+        raw = np.zeros(8192, np.int64)
+        for tap in range(4):
+            raw += win[tap] * CONVW0[:, tap].astype(np.int64)
+        raw = np.array([rne(int(v), 30) for v in raw], np.int64)   # Q16
+        conv_out[s] = np.array([silu_q16(v) for v in raw], np.int64)
+        if s == S - 1 and t0 == "0":
+            cmp(f"s{t0}_conv_raw(last)", raw.astype(np.float64) / 2**16, load_dump(f"s{t0}_conv_output_raw_0")[0].reshape(S, 8192)[-1])
+        conv_state.pop(0); conv_state.append(u)
+    cmp(f"s{t0}_conv_silu", conv_out.astype(np.float64) / 2**16, load_dump(f"s{t0}_conv_output_silu_0")[0])
+    # split + L2
+    qU = np.empty((S, HK, SDIM), np.int64); kU = np.empty((S, HK, SDIM), np.int64)
+    vQ = np.empty((S, HV, SDIM), np.int64)
+    for s in range(S):
+        row = conv_out[s]
+        for h in range(HK):
+            for (dst, base) in ((qU, 0), (kU, 2048)):
+                seg = row[base + h * SDIM: base + h * SDIM + SDIM].astype(object)
+                n = max(isqrt(int((seg * seg).sum())), 1)
+                dst[s, h] = np.array([fdiv(int(v) * (1 << 21) + n, 2 * n) for v in seg], np.int64)
+        for h in range(HV):
+            vQ[s, h] = row[4096 + h * SDIM: 4096 + h * SDIM + SDIM]
+    cmp(f"s{t0}_q_unit", qU.astype(np.float64) / 2**20, load_dump(f"s{t0}_q_conv_predelta_0")[0])
+    cmp(f"s{t0}_k_unit", kU.astype(np.float64) / 2**20, load_dump(f"s{t0}_k_conv_predelta_0")[0])
+    cmp(f"s{t0}_v", vQ.astype(np.float64) / 2**16, load_dump(f"s{t0}_v_conv_predelta_0")[0])
+    # recurrence (state Q24 int64 [HV, SDIM(i=key), SDIM(j=val)])
+    o24 = np.empty((S, HV, SDIM), np.int64)
+    for s in range(S):
+        for h in range(HV):
+            kh = h % HK
+            St = dstate[h]
+            g = int(gam24[s, h]); b = int(beta16[s, h])
+            St[...] = (St * g + (1 << 29)) >> 30
+            k_ = kU[s, kh].astype(np.int64); q_ = qU[s, kh].astype(np.int64); v_ = vQ[s, h].astype(np.int64)
+            sk = (St.T @ k_ + (1 << 19)) >> 20                     # [j] Q24
+            dlt = (((v_ << 8) - sk) * b + (1 << 15)) >> 16          # Q24
+            St += (k_[:, None] * dlt[None, :] + (1 << 19)) >> 20
+            raw = (St.T @ q_ + (1 << 19)) >> 20                     # [j] Q24
+            o24[s, h] = (raw * INV_SQRT128_Q30 + (1 << 29)) >> 30
+    st_real = np.stack([dstate[h].astype(np.float64) / 2**24 for h in range(HV)])
+    ref_state = load_dump(f"s{t0}_new_state_0")[0]  # [h, j, i]
+    cmp(f"s{t0}_state", st_real, np.transpose(ref_state, (0, 2, 1)))
+    # gated norm + silu(z)
+    y = np.empty((S, HV * SDIM), object)
+    for s in range(S):
+        for h in range(HV):
+            normed = rms_perhead(o24[s, h].astype(object), SSM_NORM0, SDIM)
+            for j in range(SDIM):
+                z16 = to_fix(z_q[s, h * SDIM + j], z_s[s], 16)
+                y[s, h * SDIM + j] = int(normed[j]) * silu_q16(z16)
+    yq, ys0 = aq_rows(y, 1 << SC)
+    ys = [rne(x, 44 + 16) for x in ys0]
+    cmp(f"s{t0}_final_output", rows_real(yq, ys), load_dump(f"s{t0}_final_output_0")[0])
+    import os
+    if os.environ.get("DIAG"):
+        ref = load_dump(f"s{t0}_final_output_0")[0].reshape(S, HV * SDIM)
+        zref = load_dump(f"s{t0}_z_0")[0].reshape(S, HV * SDIM)
+        mine = rows_real(yq, ys).reshape(S, HV * SDIM)
+        dd = np.abs(mine - ref)
+        flat = np.argsort(-dd.reshape(-1))[:12]
+        print("  DIAG worst final_output elements:")
+        for f_ in flat:
+            s_, rest = divmod(int(f_), HV * SDIM); h_, j_ = divmod(rest, SDIM)
+            zr = zref[s_, h_ * SDIM + j_]
+            sz = zr / (1.0 + np.exp(-zr))
+            o_mine = o24[s_, h_, j_] / 2**24
+            print(f"    tok{s_} head{h_} dim{j_}: mine={mine[s_,h_*SDIM+j_]:.4f} ref={ref[s_,h_*SDIM+j_]:.4f} "
+                  f"o24={o_mine:.5f} z={zr:.3f} silu_z={sz:.4f} normed_ref={ref[s_,h_*SDIM+j_]/sz if abs(sz)>1e-6 else float('nan'):.4f} "
+                  f"g={g_chk[s_,h_]:.3f}")
+        for h_ in range(0, HV):
+            seg_m = mine[:, h_*SDIM:(h_+1)*SDIM]; seg_r = ref[:, h_*SDIM:(h_+1)*SDIM]
+            e_ = np.max(np.abs(seg_m - seg_r))
+            if e_ > 0.05:
+                print(f"    head {h_}: relmax(abs)={e_:.4f} g={[round(float(g_chk[s_,h_]),2) for s_ in range(S)]}")
+    out_q, out_s = proj("blk.0.ssm_out.weight", yq, ys)
+    cmp(f"s{t0}_linear_attn_out", rows_real(out_q, out_s), load_dump(f"s{t0}_linear_attn_out_0")[0])
+    return out_q, out_s
+
+def residual_add(h_q, h_s, d_q, d_s, S):
+    out = np.empty((S, D), object)
+    for s in range(S):
+        r = (d_s[s] << SC) // h_s[s]
+        for i in range(D):
+            out[s, i] = int(h_q[s, i]) + apply(int(d_q[s, i]), r)
+    return out  # in h_s scale
+
+def moe_layer(hin_obj, h_s, S, lidx, t0):
+    L = f"blk.{lidx}."
+    gam = GAM0P if lidx == 0 else load_f32_qfix(L + "post_attention_norm.weight", 30)
+    hq64 = np.empty((S, D), np.int64)
+    for s in range(S):
+        for i in range(D): hq64[s, i] = int(hin_obj[s, i])
+    x_q, x_s = rms_q(hq64, h_s, L + "post_attention_norm.weight", gam)
+    cmp(f"s{t0}_attn_post_norm_{lidx}", rows_real(x_q, x_s), load_dump(f"s{t0}_attn_post_norm_{lidx}")[0])
+    RW = load_f32_qfix(L + "ffn_gate_inp.weight", 30)   # [256, 2048]
+    out_all = np.empty((S, D), object); out_s = []
+    for s in range(S):
+        lg = [int((x_q[s].astype(object) * RW[e].astype(object)).sum()) for e in range(NEXP)]
+        u = mul(x_s[s], 1 << 30)   # Q60 unit of logits
+        if s == S - 1:
+            cmp(f"s{t0}_moe_logits_{lidx}(last)", np.array([float(v) for v in lg]) * (u / 2**60),
+                load_dump(f"s{t0}_ffn_moe_logits_{lidx}")[0].reshape(S, NEXP)[-1])
+        m = max(lg)
+        c2048 = u * 2048
+        es = []
+        for e in range(NEXP):
+            idx = apply(m - lg[e], c2048)
+            es.append(int(EXPN[idx]) if idx < 16384 else 0)
+        den = sum(es) or 1
+        if s == S - 1:
+            pr = np.array(es, np.float64) / den
+            cmp(f"s{t0}_moe_probs_{lidx}(last)", pr, load_dump(f"s{t0}_ffn_moe_probs_{lidx}")[0].reshape(S, NEXP)[-1])
+        sel = sorted(range(NEXP), key=lambda e: (-es[e], e))[:TOPK]
+        if s == S - 1:
+            reftk = sorted(load_dump(f"s{t0}_ffn_moe_topk_{lidx}")[0].reshape(S, TOPK)[-1].astype(int).tolist())
+            same = sorted(sel) == reftk
+            print(f"  s{t0}_moe_top8_{lidx}(last) exact-set match: {'YES' if same else 'NO ' + str((sorted(sel), reftk))}")
+        w30 = [fdiv(es[e] * (1 << 30) + (den >> 1), den) for e in sel]
+        wsum = sum(w30) or 1
+        wn30 = [fdiv(w * (1 << 30) + (wsum >> 1), wsum) for w in w30]
+        # experts
+        acc_q = []; acc_s = []
+        for ei, e in enumerate(sel):
+            gq, gs = proj(L + "ffn_gate_exps.weight", x_q[s:s+1], x_s[s:s+1], row0=e * FEXP, rows=FEXP)
+            uq, us = proj(L + "ffn_up_exps.weight", x_q[s:s+1], x_s[s:s+1], row0=e * FEXP, rows=FEXP)
+            hm = np.empty((1, FEXP), object)
+            for i in range(FEXP):
+                g16 = to_fix(gq[0, i], gs[0], 16)
+                hm[0, i] = silu_q16(g16) * int(uq[0, i])
+            hq_, hs0 = aq_rows(hm, [mul(us[0], 1 << 44)])   # * 2^-16 for silu Q16
+            dq, ds = proj(L + "ffn_down_exps.weight", hq_, hs0, row0=e * D, rows=D)
+            acc_q.append(dq[0]); acc_s.append(mul(ds[0], wn30[ei] << 30))
+        smax = max(acc_s)
+        tot = np.zeros(D, object)
+        for ei in range(TOPK):
+            r = (acc_s[ei] << SC) // smax
+            for i in range(D): tot[i] += apply(int(acc_q[ei][i]), r)
+        # shared expert
+        gq, gs = proj(L + "ffn_gate_shexp.weight", x_q[s:s+1], x_s[s:s+1])
+        uq, us = proj(L + "ffn_up_shexp.weight", x_q[s:s+1], x_s[s:s+1])
+        hm = np.empty((1, FEXP), object)
+        for i in range(FEXP):
+            g16 = to_fix(gq[0, i], gs[0], 16)
+            hm[0, i] = silu_q16(g16) * int(uq[0, i])
+        hq_, hs0 = aq_rows(hm, [mul(us[0], 1 << 44)])
+        dq, ds = proj(L + "ffn_down_shexp.weight", hq_, hs0)
+        SW = load_f32_qfix(L + "ffn_gate_inp_shexp.weight", 30)
+        shl = int((x_q[s].astype(object) * SW.reshape(-1).astype(object)).sum())
+        sh16 = to_fix(shl, mul(x_s[s], 1 << 30), 16)
+        sg = int(SIG[sig_idx(sh16)])
+        shs = mul(ds[0], sg << 44)
+        # combine shared with routed
+        smax2 = max(smax, shs)
+        r1 = (smax << SC) // smax2; r2 = (shs << SC) // smax2
+        for i in range(D):
+            tot[i] = apply(int(tot[i]), r1) + apply(int(dq[0][i]), r2)
+        out_all[s] = tot; out_s.append(smax2)
+    cmp(f"s{t0}_ffn_out_{lidx}", rows_real(out_all.astype(object), out_s) if False else np.stack([np.array([float(int(v)) for v in out_all[s]]) * (out_s[s] / 2**60) for s in range(S)]), load_dump(f"s{t0}_ffn_out_{lidx}")[0])
+    q, scs = aq_rows(out_all, out_s)
+    return q, scs
+
+# ---------------- run: prefill (s0) layer 0 ----------------
+print("== embedding ==")
+h_q, h_s = embed_tokens(TOKS_S0)
+cmp("s0_embed", rows_real(h_q, h_s), load_dump("s0_model_input_embed")[0])
+
+print("== layer 0 (DeltaNet) prefill ==")
+conv_state = [np.zeros(8192, np.int64) for _ in range(3)]
+dstate = [np.zeros((SDIM, SDIM), np.int64) for _ in range(HV)]
+d_q, d_s = deltanet_layer0(h_q, h_s, 3, conv_state, dstate, "0")
+hres = residual_add(h_q, h_s, d_q, d_s, 3)
+cmp("s0_attn_residual_0", np.stack([np.array([float(int(v)) for v in hres[s]]) * (h_s[s] / 2**60) for s in range(3)]), load_dump("s0_attn_residual_0")[0])
+
+print("== layer 0 MoE prefill ==")
+m_q, m_s = moe_layer(hres, h_s, 3, 0, "0")
+lout = residual_add(hres, h_s, m_q, m_s, 3)
+cmp("s0_l_out_0", np.stack([np.array([float(int(v)) for v in lout[s]]) * (h_s[s] / 2**60) for s in range(3)]), load_dump("s0_l_out_0")[0])
+
+print("== decode step (s1) layer 0 ==")
+h1_q, h1_s = embed_tokens(TOK_S1)
+cmp("s1_embed", rows_real(h1_q, h1_s), load_dump("s1_model_input_embed")[0])
+d1_q, d1_s = deltanet_layer0(h1_q, h1_s, 1, conv_state, dstate, "1")
+hres1 = residual_add(h1_q, h1_s, d1_q, d1_s, 1)
+m1_q, m1_s = moe_layer(hres1, h1_s, 1, 0, "1")
+
+print("\n==== SUMMARY ====")
+worst = sorted(REPORT, key=lambda r: -r[1])[:10]
+for tag, err, rmse, sc in worst:
+    print(f"  WORST {tag:36s} relmax={err:9.3e} relrmse={rmse:9.3e}")
+ok = all(r[1] < 0.05 for r in REPORT)
+print("GATE G2 (layer0+MoE, <5% relmax):", "PASS" if ok else "CHECK")
+
+# ================= layer 3: full attention (input = fp l_out_2, isolated layer test) =================
+COSQ, SINQ = rope_tables(16)
+GQ3 = load_f32_qfix("blk.3.attn_q_norm.weight", 30)
+GK3 = load_f32_qfix("blk.3.attn_k_norm.weight", 30)
+GN3 = load_f32_qfix("blk.3.attn_norm.weight", 30)
+
+def import_fp(name, S):
+    v = load_dump(name)[0].reshape(S, D)
+    q = np.empty((S, D), object)
+    for s in range(S):
+        for i in range(D): q[s, i] = int(round(float(v[s, i]) * (1 << 40)))
+    return q, [q60(1, -40)] * S
+
+def rms_vec_units(vals, s_scale, gQ30, N):
+    # per-head rms over A24 slice with proper real eps; returns object ints (unit 2^-74 of input-normalized)
+    ss = int(sum(int(v) * int(v) for v in vals))
+    U = (1 << 60) // int(s_scale)
+    eps_int = (EPS_Q40 * U * U) >> 40
+    mean = ss // N + eps_int + 1
+    inv = isqrt((1 << 88) // mean)
+    return [rne(int(v) * inv * int(g), 30) for v, g in zip(vals, gQ30)]
+
+def rope_apply(vals, pos, nh):
+    # vals int64 [nh, 256] any fixed scale; rotate dims (i, i+32) for i<32 with Q30 tables
+    out = vals.copy()
+    for h in range(nh):
+        for i in range(NROT // 2):
+            x0 = int(vals[h, i]); x1 = int(vals[h, i + NROT // 2])
+            c = int(COSQ[pos, i]); sn = int(SINQ[pos, i])
+            out[h, i] = rne(x0 * c - x1 * sn, 30)
+            out[h, i + NROT // 2] = rne(x0 * sn + x1 * c, 30)
+    return out
+
+KV_K16 = []; KV_V16 = []   # per past token: [NKV, 256] Q16 absolute
+
+def attn_layer3(S, t0, pos0):
+    h_q, h_s = import_fp(f"s{t0}_l_out_2", S)
+    hq64 = np.empty((S, D), np.int64)
+    for s in range(S):
+        for i in range(D): hq64[s, i] = int(h_q[s, i])
+    x_q, x_s = rms_q(hq64, h_s, "blk.3.attn_norm.weight", GN3)
+    cmp(f"s{t0}_attn_norm_3", rows_real(x_q, x_s), load_dump(f"s{t0}_attn_norm_3")[0])
+    qf_q, qf_s = proj("blk.3.attn_q.weight", x_q, x_s)
+    cmp(f"s{t0}_Qcur_full_3", rows_real(qf_q, qf_s), load_dump(f"s{t0}_Qcur_full_3")[0])
+    k_q, k_s = proj("blk.3.attn_k.weight", x_q, x_s)
+    v_q, v_s = proj("blk.3.attn_v.weight", x_q, x_s)
+    cmp(f"s{t0}_Vcur_3", rows_real(v_q, v_s), load_dump(f"s{t0}_Vcur_3")[0])
+    # split q/gate, per-head q,k norm -> aq per token
+    qn = np.empty((S, NH, HD), object); gate = np.empty((S, NH, HD), np.int64)
+    kn = np.empty((S, NKV, HD), object)
+    for s in range(S):
+        for h in range(NH):
+            seg = [int(qf_q[s, 512 * h + d]) for d in range(HD)]
+            qn[s, h] = rms_vec_units(seg, qf_s[s], GQ3, HD)
+            for d in range(HD): gate[s, h, d] = qf_q[s, 512 * h + 256 + d]
+        for h in range(NKV):
+            seg = [int(k_q[s, 256 * h + d]) for d in range(HD)]
+            kn[s, h] = rms_vec_units(seg, k_s[s], GK3, HD)
+    qn_q, qn_s = aq_rows(qn.reshape(S, NH * HD), 1 << SC)
+    qn_s = [rne(x, 44) for x in qn_s]
+    kn_q, kn_s = aq_rows(kn.reshape(S, NKV * HD), 1 << SC)
+    kn_s = [rne(x, 44) for x in kn_s]
+    cmp(f"s{t0}_Qcur_normed_3", rows_real(qn_q, qn_s), load_dump(f"s{t0}_Qcur_normed_3")[0])
+    cmp(f"s{t0}_Kcur_normed_3", rows_real(kn_q, kn_s), load_dump(f"s{t0}_Kcur_normed_3")[0])
+    # rope
+    qr = np.empty((S, NH, HD), np.int64); kr = np.empty((S, NKV, HD), np.int64)
+    for s in range(S):
+        qr[s] = rope_apply(qn_q[s].reshape(NH, HD), pos0 + s, NH)
+        kr[s] = rope_apply(kn_q[s].reshape(NKV, HD), pos0 + s, NKV)
+    cmp(f"s{t0}_Qcur_3", rows_real(qr.reshape(S, NH * HD), qn_s), load_dump(f"s{t0}_Qcur_3")[0])
+    cmp(f"s{t0}_Kcur_3(roped)", rows_real(kr.reshape(S, NKV * HD), kn_s), load_dump(f"s{t0}_Kcur_3__1")[0])
+    # KV cache append in absolute Q16
+    for s in range(S):
+        K16 = np.empty((NKV, HD), np.int64); V16 = np.empty((NKV, HD), np.int64)
+        for h in range(NKV):
+            for d in range(HD):
+                K16[h, d] = to_fix(kr[s, h, d], kn_s[s], 16)
+                V16[h, d] = to_fix(v_q[s, 256 * h + d], v_s[s], 16)
+        KV_K16.append(K16); KV_V16.append(V16)
+    # attention per head, per token
+    att = np.empty((S, NH, HD), object)
+    for s in range(S):
+        T = pos0 + s + 1
+        cQ = rne(qn_s[s] * 128, 16)     # idx units: (q*k16)*qs*2^-16 /16 *2048
+        for h in range(NH):
+            kvh = h // (NH // NKV)
+            sc_row = [int(np.dot(qr[s, h].astype(np.int64), KV_K16[t][kvh].astype(np.int64))) for t in range(T)]
+            m = max(sc_row)
+            es = []
+            for t in range(T):
+                idx = apply(m - sc_row[t], cQ)
+                es.append(int(EXPN[idx]) if idx < 16384 else 0)
+            den = sum(es) or 1
+            for d in range(HD):
+                acc = sum(es[t] * int(KV_V16[t][kvh][d]) for t in range(T))
+                av = fdiv(acc * (1 << SC) + (den >> 1), den) >> SC   # Q16 abs
+                g16 = to_fix(gate[s, h, d], qf_s[s], 16)
+                att[s, h, d] = av * int(SIG[sig_idx(g16)])           # Q32 abs
+    cmp(f"s{t0}_attn_pregate_3", np.stack([np.array([float(int(v)) / 2**32 * 2**16 for v in att[s].reshape(-1)]) for s in range(S)]) * 0 + np.stack([np.array([float(sum(int(EXPN[apply(0,1)]) for _ in [])) for _ in range(1)])]) if False else np.stack([np.array([float(int(att[s].reshape(-1)[i])) / (float(int(SIG[sig_idx(to_fix(gate[s, i // HD, i % HD], qf_s[s], 16))])) or 1.0) / 2**16 for i in range(NH * HD)]) for s in range(S)]), load_dump(f"s{t0}_attn_pregate_3")[0])
+    aq_in = np.empty((S, NH * HD), object)
+    for s in range(S):
+        aq_in[s] = att[s].reshape(-1)
+    at_q, at_s0 = aq_rows(aq_in, 1 << SC)
+    at_s = [rne(x, 32) for x in at_s0]
+    cmp(f"s{t0}_attn_gated_3", rows_real(at_q, at_s), load_dump(f"s{t0}_attn_gated_3")[0])
+    o_q, o_s = proj("blk.3.attn_output.weight", at_q, at_s)
+    cmp(f"s{t0}_attn_output_3", rows_real(o_q, o_s), load_dump(f"s{t0}_attn_output_3")[0])
+    hres = residual_add(h_q, h_s, o_q, o_s, S)
+    cmp(f"s{t0}_attn_residual_3", np.stack([np.array([float(int(v)) for v in hres[s]]) * (h_s[s] / 2**60) for s in range(S)]), load_dump(f"s{t0}_attn_residual_3")[0])
+    m_q, m_s = moe_layer(hres, h_s, S, 3, t0)
+    lout = residual_add(hres, h_s, m_q, m_s, S)
+    cmp(f"s{t0}_l_out_3", np.stack([np.array([float(int(v)) for v in lout[s]]) * (h_s[s] / 2**60) for s in range(S)]), load_dump(f"s{t0}_l_out_3")[0])
+
+print("== layer 3 (attention) prefill ==")
+attn_layer3(3, "0", 0)
+print("== layer 3 (attention) decode ==")
+attn_layer3(1, "1", 3)
+
+print("\n==== FINAL SUMMARY ====")
+worst = sorted(REPORT, key=lambda r: -r[1])[:8]
+for tag, err, rmse, sc in worst:
+    print(f"  WORST {tag:36s} relmax={err:9.3e} relrmse={rmse:9.3e}")
+ok = all(r[1] < 0.05 for r in REPORT)
+print("GATE G2 (layers 0+3 + MoE, <5% relmax):", "PASS" if ok else "CHECK")
diff --git a/docs/evidence/qi35_metal_at.m b/docs/evidence/qi35_metal_at.m
new file mode 100644
index 0000000000000000000000000000000000000000..e676b05c4cc0a4211acbb7239118e194201e5b18
--- /dev/null
+++ b/docs/evidence/qi35_metal_at.m
@@ -0,0 +1,429 @@
+// qi35_metal_at — QI35-5 v3 Phase C: the ENTIRE full-attention block on-device in ONE commit.
+// Bit-exact contract: every kernel reproduces the frozen CPU semantics of qi35_model.rs
+// attention() exactly — I128 two-word arithmetic, RNE via (x + 2^(s-1)) >> s arithmetic shifts,
+// floor division (div_euclid), per-token eps (u = min(2^60/s, 2^40)), full i128 Newton isqrt
+// (2^88/mean can exceed u64 when a head segment is near-zero), Q30 RoPE on A24 ints, expn LUT
+// softmax with exact I128 score dots, sigmoid output gating.
+// KV cache lives in Rust page-aligned memory (smax rows pre-allocated) wrapped as no-copy
+// MTLBuffers: GPU appends in place, CPU fallback/shadow/kv_root read the very same bytes.
+// Reuses from Phase A/B: qi35_pGemm4/qi35_pGemm6 (GEMM), qi35_pFinish (proj_finish),
+// qi35_pFinq128 (I128 aq + scale, shift parameterized). Compiled together with
+// qi35_metal_shim.m + qi35_metal_moe.m + qi35_metal_dn.m.
+#import <Foundation/Foundation.h>
+#import <Metal/Metal.h>
+
+// from qi35_metal_shim.m
+extern id<MTLDevice> qi35_dev(void);
+extern id<MTLCommandQueue> qi35_queue(void);
+extern id<MTLBuffer> qi35_buffer_for(const void *w_ptr, unsigned long long w_len, unsigned long long *delta_out);
+// from qi35_metal_moe.m (init order: moe -> dn -> at)
+extern id<MTLComputePipelineState> qi35_pFinish;
+extern id<MTLComputePipelineState> qi35_pGemm4, qi35_pGemm6;
+// from qi35_metal_dn.m
+extern id<MTLComputePipelineState> qi35_pFinq128;
+
+static id<MTLComputePipelineState> pAtQknorm, pAtRope, pAtKv, pAtCore;
+static id<MTLBuffer> bAtXq, bAtRegs, bAtAcc, bAtColsq, bAtResc, bAtQ, bAtSel;
+static id<MTLBuffer> bAtQn, bAtKn, bAtQnQ, bAtKnQ, bAtAtt, bAtAtq, bAtScr, bAtEs;
+static id<MTLBuffer> bAtCos, bAtSin, bAtSig, bAtExpn;
+static id<MTLBuffer> bAtW[64], bAtK[64], bAtV[64];
+static unsigned gAtSmax;
+
+// Row layout inside the shared ACC/COLSQ/RESC/Q buffers:
+//   [0..8192)      qf   (attn_q,      k=2048, nsb=8)  — interleaved per head [q256, gate256]
+//   [8192..8704)   k    (attn_k,      k=2048, nsb=8)
+//   [8704..9216)   v    (attn_v,      k=2048, nsb=8)
+//   [9216..11264)  out  (attn_output, k=4096, nsb=16)
+// REGS (I128 slots): 0=xs  1=s_qf  2=s_k  3=s_v  5=qn_s  6=kn_s  7=at_s  9=s_out  10=cq
+#define AT_ROWS_TOTAL 11264
+#define AT_OFF_QF 0
+#define AT_OFF_K 8192
+#define AT_OFF_V 8704
+#define AT_OFF_OUT 9216
+
+static NSString *const kAtSrc = @""
+"#include <metal_stdlib>\n"
+"using namespace metal;\n"
+"struct I128 { ulong lo; long hi; };\n"
+"static inline I128 mk64(long v) { I128 r; r.lo = (ulong)v; r.hi = v < 0 ? -1 : 0; return r; }\n"
+"static inline I128 addi(I128 a, I128 b) { I128 r; r.lo = a.lo + b.lo; r.hi = a.hi + b.hi + (long)(r.lo < a.lo ? 1 : 0); return r; }\n"
+"static inline I128 negi(I128 a) { I128 r; r.lo = ~a.lo; r.hi = ~a.hi; r.lo += 1; if (r.lo == 0) r.hi += 1; return r; }\n"
+"static inline bool isneg(I128 a) { return a.hi < 0; }\n"
+"static inline bool lti(I128 a, I128 b) { return a.hi < b.hi || (a.hi == b.hi && a.lo < b.lo); }\n"
+"static inline bool ltu(I128 a, I128 b) { ulong ah = (ulong)a.hi, bh = (ulong)b.hi; return ah < bh || (ah == bh && a.lo < b.lo); }\n"
+"static inline I128 shli(I128 a, uint s) { I128 r; if (s == 0) return a; if (s >= 64) { r.lo = 0; r.hi = (long)(a.lo << (s - 64)); } else { r.lo = a.lo << s; r.hi = (long)(((ulong)a.hi << s) | (a.lo >> (64 - s))); } return r; }\n"
+"static inline I128 shri(I128 a, uint s) { I128 r; if (s == 0) return a; if (s >= 64) { r.lo = (ulong)(a.hi >> (s - 64)); r.hi = a.hi >> 63; } else { r.lo = (a.lo >> s) | ((ulong)a.hi << (64 - s)); r.hi = a.hi >> s; } return r; }\n"
+"static inline I128 mag(I128 a) { return isneg(a) ? negi(a) : a; }\n"
+"static inline I128 mulmag_u64(I128 a, ulong b) { I128 r; r.lo = a.lo * b; ulong h = mulhi(a.lo, b); r.hi = (long)(h + (ulong)a.hi * b); return r; }\n"
+"static inline I128 muli_u64(I128 a, ulong b) { bool n = isneg(a); I128 m = mulmag_u64(mag(a), b); return n ? negi(m) : m; }\n"
+"static inline I128 muli_i64(I128 a, long b) { bool nb = b < 0; ulong ub = (ulong)(nb ? -b : b); I128 m = muli_u64(a, ub); return nb ? negi(m) : m; }\n"
+"static inline I128 divmag(I128 num, I128 den, thread I128 *rem_out) {\n"
+"    I128 q; q.lo = 0; q.hi = 0; I128 r; r.lo = 0; r.hi = 0;\n"
+"    for (int i = 127; i >= 0; i--) {\n"
+"        r = shli(r, 1);\n"
+"        ulong bit = (i >= 64) ? (((ulong)num.hi >> (i - 64)) & 1) : ((num.lo >> i) & 1);\n"
+"        r.lo |= bit;\n"
+"        if (!ltu(r, den)) { r = addi(r, negi(den)); if (i >= 64) q.hi |= (long)(1ul << (i - 64)); else q.lo |= (1ul << i); }\n"
+"    }\n"
+"    if (rem_out) *rem_out = r;\n"
+"    return q;\n"
+"}\n"
+"static inline I128 fdivi(I128 num, I128 den) {\n"
+"    bool n = isneg(num); I128 r; I128 q = divmag(mag(num), mag(den), &r);\n"
+"    if (n && (r.lo | (ulong)r.hi) != 0) { q = addi(q, mk64(1)); return negi(q); }\n"
+"    return n ? negi(q) : q;\n"
+"}\n"
+"static inline I128 halfc() { I128 h; h.lo = 1ul << 59; h.hi = 0; return h; }\n"
+"// apply(a, s) = (a*s + HALF) >> 60 with s fitting u64 (same convention as moe k_topk c2)\n"
+"static inline I128 applyu(I128 a, ulong s) { return shri(addi(muli_u64(a, s), halfc()), 60); }\n"
+"// to_fix(a, s, 16) = rne(a*s, 44) with a fitting i64 and s an I128 Q60 scale\n"
+"static inline long tofix16(I128 s, long a) { return (long)(shri(addi(muli_i64(s, a), mk64(1l << 43)), 44).lo); }\n"
+"// sig LUT index: clamp(rne(x, 7) + 8192, 0, 16383)\n"
+"static inline long sigidx(long x) { return clamp(((x + 64) >> 7) + 8192, 0l, 16383l); }\n"
+"// full i128 Newton isqrt, identical iteration sequence to Rust isqrt(n: i128).\n"
+"// needed because 2^88/mean exceeds u64 when mean < 2^24 (near-zero head segment + tiny eps).\n"
+"// terminates in <= ~90 iterations for n <= 2^88; cap 200 is mathematically unreachable.\n"
+"static inline I128 isqrt128(I128 n) {\n"
+"    I128 z; z.lo = 0; z.hi = 0;\n"
+"    if (n.hi < 0 || (n.hi == 0 && n.lo == 0)) return z;\n"
+"    I128 x = n;\n"
+"    I128 y = shri(addi(x, mk64(1)), 1);\n"
+"    for (int it = 0; it < 200 && ltu(y, x); it++) {\n"
+"        x = y;\n"
+"        I128 q = divmag(n, x, 0);\n"
+"        y = shri(addi(x, q), 1);\n"
+"    }\n"
+"    return x;\n"
+"}\n"
+"// ---- 1. per-head q/k RMS norm (rms_perhead_a24): per-token eps, i128 isqrt ----\n"
+"// tg 0..15 = q heads: seg = Q[512*tg + d] (first 256 of the [q256,gate256] block), s = REGS[1], gam = W[d]\n"
+"// tg 16..17 = k heads: seg = Q[8192 + 256*(tg-16) + d], s = REGS[2], gam = W[256 + d]\n"
+"kernel void k_at_qknorm(device const int* Q [[buffer(0)]], device I128* REGS [[buffer(1)]],\n"
+"                        device const long* W [[buffer(2)]], device I128* QN [[buffer(3)]],\n"
+"                        device I128* KN [[buffer(4)]],\n"
+"                        uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]]) {\n"
+"    threadgroup ulong sh[256];\n"
+"    threadgroup ulong tg_inv;\n"
+"    bool isq = tg < 16;\n"
+"    long v = isq ? (long)Q[512 * tg + tid] : (long)Q[8192 + 256 * (tg - 16) + tid];\n"
+"    long gm = isq ? W[tid] : W[256 + tid];\n"
+"    sh[tid] = (ulong)(v * v);\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = 128; s > 0; s >>= 1) { if (tid < s) sh[tid] += sh[tid + s]; threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    if (tid == 0) {\n"
+"        I128 s = REGS[isq ? 1 : 2];\n"
+"        I128 u = divmag(shli(mk64(1), 60), s, 0);\n"
+"        I128 u40 = shli(mk64(1), 40);\n"
+"        if (ltu(u40, u)) u = u40;\n"
+"        I128 usq = mulmag_u64(u, u.lo);\n"
+"        I128 eps = shri(muli_u64(usq, 1099512ul), 40);\n"
+"        I128 mean = addi(addi(shri(mk64((long)sh[0]), 8), eps), mk64(1));\n"
+"        I128 qd = divmag(shli(mk64(1), 88), mean, 0);\n"
+"        tg_inv = isqrt128(qd).lo;\n"
+"    }\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    ulong inv = tg_inv;\n"
+"    I128 t = muli_u64(mk64(v), inv);\n"
+"    t = muli_i64(t, gm);\n"
+"    I128 normed = shri(addi(t, mk64(1l << 29)), 30);\n"
+"    if (isq) QN[tg * 256 + tid] = normed; else KN[(tg - 16) * 256 + tid] = normed;\n"
+"}\n"
+"// ---- 2. RoPE on A24 ints (post-aq, matches CPU qr/kr clone-then-rotate) ----\n"
+"// gid < 512: q pairs (h = gid/32, i = gid%32); gid in [512,576): k pairs.\n"
+"// x0*c and x1*sn fit i64 (|x| <= 2^24, |c| <= 2^30); rne identical to CPU i128 path.\n"
+"struct RP { uint pos; uint p0; uint p1; uint p2; };\n"
+"kernel void k_at_rope(device int* QNQ [[buffer(0)]], device int* KNQ [[buffer(1)]],\n"
+"                      device const long* COS [[buffer(2)]], device const long* SIN [[buffer(3)]],\n"
+"                      constant RP& p [[buffer(4)]], uint gid [[thread_position_in_grid]]) {\n"
+"    if (gid >= 576) return;\n"
+"    device int* A; uint h, i;\n"
+"    if (gid < 512) { A = QNQ; h = gid / 32; i = gid % 32; }\n"
+"    else { A = KNQ; h = (gid - 512) / 32; i = (gid - 512) % 32; }\n"
+"    long x0 = (long)A[h * 256 + i];\n"
+"    long x1 = (long)A[h * 256 + i + 32];\n"
+"    long c = COS[p.pos * 32 + i], sn = SIN[p.pos * 32 + i];\n"
+"    A[h * 256 + i] = (int)((x0 * c - x1 * sn + (1l << 29)) >> 30);\n"
+"    A[h * 256 + i + 32] = (int)((x0 * sn + x1 * c + (1l << 29)) >> 30);\n"
+"}\n"
+"// ---- 3. KV append (absolute Q16) into the resident cache + cq by thread 0 ----\n"
+"// KC/VC row layout: [(pos*2 + h)*256 + d] — identical to the CPU push order.\n"
+"kernel void k_at_kv(device const int* KNQ [[buffer(0)]], device const int* Q [[buffer(1)]],\n"
+"                    device I128* REGS [[buffer(2)]], device long* KC [[buffer(3)]],\n"
+"                    device long* VC [[buffer(4)]], constant RP& p [[buffer(5)]],\n"
+"                    uint gid [[thread_position_in_grid]]) {\n"
+"    if (gid >= 512) return;\n"
+"    uint h = gid / 256, d = gid % 256;\n"
+"    KC[((ulong)p.pos * 2 + h) * 256 + d] = tofix16(REGS[6], (long)KNQ[h * 256 + d]);\n"
+"    VC[((ulong)p.pos * 2 + h) * 256 + d] = tofix16(REGS[3], (long)Q[8704 + h * 256 + d]);\n"
+"    if (gid == 0) REGS[10] = shri(addi(shli(REGS[5], 7), mk64(1l << 15)), 16); // cq = rne(qn_s*128, 16)\n"
+"}\n"
+"// ---- 4. attention core: one threadgroup per q head (16), 256 threads ----\n"
+"// kvh = tg/8 (GQA). scr/es in device scratch (tlen can be up to smax).\n"
+"// exact I128 score dots; m = signed max; es = expn LUT at applyu(m-scr, cq); den exact sum;\n"
+"// out_d = fdiv(acc*2^60 + den/2, den) >> 60, gated by sigmoid(gate16) -> ATT (I128, Q32).\n"
+"struct CP { uint tlen; uint kvmax; uint p0; uint p1; };\n"
+"kernel void k_at_core(device const int* QNQ [[buffer(0)]], device const long* KC [[buffer(1)]],\n"
+"                      device const long* VC [[buffer(2)]], device const int* Q [[buffer(3)]],\n"
+"                      device I128* REGS [[buffer(4)]], device const long* SIG [[buffer(5)]],\n"
+"                      device const long* EXPN [[buffer(6)]], device I128* SCR [[buffer(7)]],\n"
+"                      device I128* ES [[buffer(8)]], device I128* ATT [[buffer(9)]],\n"
+"                      constant CP& p [[buffer(10)]],\n"
+"                      uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]]) {\n"
+"    threadgroup I128 sh[256];\n"
+"    threadgroup I128 tg_bcast;\n"
+"    uint kvh = tg / 8;\n"
+"    device I128* scr = SCR + (ulong)tg * p.kvmax;\n"
+"    device I128* es = ES + (ulong)tg * p.kvmax;\n"
+"    // scores: each thread owns t = tid, tid+256, ... (exact integer sum, order-free)\n"
+"    I128 mymax; mymax.lo = 0; mymax.hi = (long)0x8000000000000000; // -2^127 sentinel\n"
+"    for (uint t = tid; t < p.tlen; t += 256) {\n"
+"        I128 acc; acc.lo = 0; acc.hi = 0;\n"
+"        device const long* krow = KC + ((ulong)t * 2 + kvh) * 256;\n"
+"        for (uint d = 0; d < 256; d++) acc = addi(acc, muli_i64(mk64((long)QNQ[tg * 256 + d]), krow[d]));\n"
+"        scr[t] = acc;\n"
+"        if (lti(mymax, acc)) mymax = acc;\n"
+"    }\n"
+"    sh[tid] = mymax;\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = 128; s > 0; s >>= 1) { if (tid < s) { if (lti(sh[tid], sh[tid + s])) sh[tid] = sh[tid + s]; } threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    if (tid == 0) tg_bcast = sh[0];\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    I128 m = tg_bcast;\n"
+"    ulong cq = REGS[10].lo;\n"
+"    // es + den partials (each thread over its own t's; scr[t] written by this thread)\n"
+"    I128 myden; myden.lo = 0; myden.hi = 0;\n"
+"    for (uint t = tid; t < p.tlen; t += 256) {\n"
+"        I128 d = addi(m, negi(scr[t]));\n"
+"        I128 idx = applyu(d, cq);\n"
+"        long ix = (long)idx.lo; if (idx.hi != 0) ix = 999999;\n"
+"        // ix<0 only when idx.lo in [2^63,2^64): CPU expn_at sees idx>=16384 -> 0; guard also kills the OOB read\n"
+"        long ev = (ix >= 0 && ix < 16384) ? EXPN[ix] : 0;\n"
+"        es[t] = mk64(ev);\n"
+"        myden = addi(myden, mk64(ev));\n"
+"    }\n"
+"    sh[tid] = myden;\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = 128; s > 0; s >>= 1) { if (tid < s) sh[tid] = addi(sh[tid], sh[tid + s]); threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    if (tid == 0) { I128 dd = sh[0]; if (dd.lo == 0 && dd.hi == 0) dd = mk64(1); tg_bcast = dd; }\n"
+"    threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup); // es (device) + tg_bcast (tg)\n"
+"    I128 den = tg_bcast;\n"
+"    // weighted V + sigmoid gate: one thread per output dim d\n"
+"    uint d = tid;\n"
+"    I128 acc; acc.lo = 0; acc.hi = 0;\n"
+"    for (uint t = 0; t < p.tlen; t++) {\n"
+"        long ev = (long)es[t].lo;\n"
+"        acc = addi(acc, muli_i64(mk64(VC[((ulong)t * 2 + kvh) * 256 + d]), ev));\n"
+"    }\n"
+"    I128 num = addi(shli(acc, 60), shri(den, 1));\n"
+"    I128 av = shri(fdivi(num, den), 60);\n"
+"    long g16 = tofix16(REGS[1], (long)Q[512 * tg + 256 + d]);\n"
+"    ATT[tg * 256 + d] = muli_u64(av, (ulong)SIG[sigidx(g16)]);\n"
+"}\n";
+
+int qi35_at_init(const long *sig, const long *expn, const long *cosT, const long *sinT, unsigned smax) {
+    id<MTLDevice> dev = qi35_dev();
+    NSError *err = nil;
+    id<MTLLibrary> lib = [dev newLibraryWithSource:kAtSrc options:nil error:&err];
+    if (!lib) { fprintf(stderr, "qi35at: %s\n", err.description.UTF8String); return -1; }
+    #define APIPE(v, n) v = [dev newComputePipelineStateWithFunction:[lib newFunctionWithName:@n] error:&err]; if (!v) { fprintf(stderr, "qi35at pipe %s\n", n); return -2; }
+    APIPE(pAtQknorm, "k_at_qknorm"); APIPE(pAtRope, "k_at_rope"); APIPE(pAtKv, "k_at_kv"); APIPE(pAtCore, "k_at_core");
+    gAtSmax = smax;
+    bAtSig = [dev newBufferWithBytes:sig length:16384 * 8 options:MTLResourceStorageModeShared];
+    bAtExpn = [dev newBufferWithBytes:expn length:16384 * 8 options:MTLResourceStorageModeShared];
+    bAtCos = [dev newBufferWithBytes:cosT length:(NSUInteger)smax * 32 * 8 options:MTLResourceStorageModeShared];
+    bAtSin = [dev newBufferWithBytes:sinT length:(NSUInteger)smax * 32 * 8 options:MTLResourceStorageModeShared];
+    bAtXq = [dev newBufferWithLength:2048 * 4 options:MTLResourceStorageModeShared];
+    bAtRegs = [dev newBufferWithLength:256 * 16 options:MTLResourceStorageModeShared];
+    bAtAcc = [dev newBufferWithLength:AT_ROWS_TOTAL * 24 options:MTLResourceStorageModeShared];
+    bAtColsq = [dev newBufferWithLength:AT_ROWS_TOTAL * 16 options:MTLResourceStorageModeShared];
+    bAtResc = [dev newBufferWithLength:AT_ROWS_TOTAL * 8 options:MTLResourceStorageModeShared];
+    bAtQ = [dev newBufferWithLength:AT_ROWS_TOTAL * 4 options:MTLResourceStorageModeShared];
+    bAtSel = [dev newBufferWithLength:8 * 4 options:MTLResourceStorageModeShared];
+    memset(bAtSel.contents, 0, 8 * 4);
+    bAtQn = [dev newBufferWithLength:4096 * 16 options:MTLResourceStorageModeShared];
+    bAtKn = [dev newBufferWithLength:512 * 16 options:MTLResourceStorageModeShared];
+    bAtQnQ = [dev newBufferWithLength:4096 * 4 options:MTLResourceStorageModeShared];
+    bAtKnQ = [dev newBufferWithLength:512 * 4 options:MTLResourceStorageModeShared];
+    bAtAtt = [dev newBufferWithLength:4096 * 16 options:MTLResourceStorageModeShared];
+    bAtAtq = [dev newBufferWithLength:4096 * 4 options:MTLResourceStorageModeShared];
+    bAtScr = [dev newBufferWithLength:(NSUInteger)16 * smax * 16 options:MTLResourceStorageModeShared];
+    bAtEs = [dev newBufferWithLength:(NSUInteger)16 * smax * 16 options:MTLResourceStorageModeShared];
+    return 0;
+}
+
+void qi35_at_upload_layer(unsigned layer, const long *qnorm30, const long *knorm30) {
+    // one buffer per layer: qnorm[256] | knorm[256]
+    id<MTLBuffer> b = [qi35_dev() newBufferWithLength:512 * 8 options:MTLResourceStorageModeShared];
+    memcpy(b.contents, qnorm30, 256 * 8);
+    memcpy((char *)b.contents + 256 * 8, knorm30, 256 * 8);
+    bAtW[layer] = b;
+}
+
+int qi35_at_bind_kv(unsigned layer, void *k_ptr, unsigned long long k_len, void *v_ptr, unsigned long long v_len) {
+    id<MTLDevice> dev = qi35_dev();
+    // Untracked hazard mode: 20 x 64MB tracked no-copy buffers were measured to slow EVERY
+    // command buffer's commit (moe 151ms -> 1.5s/token) via per-commit residency/hazard scans.
+    // Safe here: within one CB the kv->core dependency is ordered by an explicit memoryBarrier,
+    // and across CBs by waitUntilCompleted (fully synchronous engine).
+    MTLResourceOptions opt = MTLResourceStorageModeShared | MTLResourceHazardTrackingModeUntracked;
+    bAtK[layer] = [dev newBufferWithBytesNoCopy:k_ptr length:k_len options:opt deallocator:nil];
+    bAtV[layer] = [dev newBufferWithBytesNoCopy:v_ptr length:v_len options:opt deallocator:nil];
+    if (!bAtK[layer] || !bAtV[layer]) { fprintf(stderr, "qi35at: no-copy kv buffer failed layer %u\n", layer); return -1; }
+    return 0;
+}
+
+typedef struct { const void *ptr[4]; unsigned long long len[4]; unsigned ty[4]; unsigned layer; unsigned pos; } AtTensors;
+
+static void encAtGemm(id<MTLComputeCommandEncoder> e, unsigned ty, const void *ptr, unsigned long long len,
+                      unsigned rows, unsigned nsb, id<MTLBuffer> xbuf, unsigned long accOff) {
+    unsigned long long d;
+    id<MTLBuffer> wb = qi35_buffer_for(ptr, len, &d);
+    struct MPh { unsigned nsb, rows, nseg, fexp; unsigned long long toff; unsigned segsexp, which, segbase, pad; } mp =
+        { nsb, rows, 1, 0, d, 0, 0, 0, 0 };
+    [e setComputePipelineState:(ty == 12 ? qi35_pGemm4 : qi35_pGemm6)];
+    [e setBuffer:wb offset:0 atIndex:0];
+    [e setBuffer:xbuf offset:0 atIndex:1];
+    [e setBuffer:bAtAcc offset:accOff * 24 atIndex:2];
+    [e setBytes:&mp length:sizeof(mp) atIndex:3];
+    [e setBuffer:bAtSel offset:0 atIndex:4];
+    [e dispatchThreads:MTLSizeMake(rows, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+}
+
+static void encAtFinish(id<MTLComputeCommandEncoder> e, unsigned rows, unsigned long off, unsigned xs_slot, unsigned sout) {
+    struct { unsigned rows, xs_slot, xs_per_seg, sout_base; } ff = { rows, xs_slot, 0, sout };
+    [e setComputePipelineState:qi35_pFinish];
+    [e setBuffer:bAtAcc offset:off * 24 atIndex:0];
+    [e setBuffer:bAtColsq offset:off * 16 atIndex:1];
+    [e setBuffer:bAtResc offset:off * 8 atIndex:2];
+    [e setBuffer:bAtQ offset:off * 4 atIndex:3];
+    [e setBuffer:bAtRegs offset:0 atIndex:4];
+    [e setBytes:&ff length:sizeof(ff) atIndex:5];
+    [e dispatchThreadgroups:MTLSizeMake(1, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+}
+
+static void encAtFinq(id<MTLComputeCommandEncoder> e, id<MTLBuffer> ybuf, id<MTLBuffer> qbuf,
+                      unsigned n, unsigned ys_slot, unsigned shift) {
+    struct { unsigned n, ys_slot, shift, p1; } fq = { n, ys_slot, shift, 0 };
+    [e setComputePipelineState:qi35_pFinq128];
+    [e setBuffer:ybuf offset:0 atIndex:0];
+    [e setBuffer:qbuf offset:0 atIndex:1];
+    [e setBuffer:bAtRegs offset:0 atIndex:2];
+    [e setBytes:&fq length:sizeof(fq) atIndex:3];
+    [e dispatchThreadgroups:MTLSizeMake(1, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+}
+
+static int at_stage(void) {
+    static int st = -1;
+    if (st < 0) { const char *e = getenv("QI35_AT_STAGE"); st = e ? atoi(e) : 0; }
+    return st;
+}
+
+int qi35_at_run(const AtTensors *t, const int *xq, const unsigned char *xs16, int *mq_out, unsigned char *ms16_out) {
+    memcpy(bAtXq.contents, xq, 2048 * 4);
+    memcpy(bAtRegs.contents, xs16, 16); // slot 0 = xs
+    id<MTLBuffer> wl = bAtW[t->layer];
+    id<MTLCommandBuffer> cb = [qi35_queue() commandBuffer];
+    id<MTLComputeCommandEncoder> e = [cb computeCommandEncoderWithDispatchType:MTLDispatchTypeConcurrent];
+    #define ATBARRIER [e memoryBarrierWithScope:MTLBarrierScopeBuffers]
+    struct RP { unsigned pos, p0, p1, p2; } rp = { t->pos, 0, 0, 0 };
+
+    // ---- phase 1 (concurrent): the three input GEMMs ----
+    encAtGemm(e, t->ty[0], t->ptr[0], t->len[0], 8192, 8, bAtXq, AT_OFF_QF);
+    encAtGemm(e, t->ty[1], t->ptr[1], t->len[1], 512, 8, bAtXq, AT_OFF_K);
+    encAtGemm(e, t->ty[2], t->ptr[2], t->len[2], 512, 8, bAtXq, AT_OFF_V);
+    ATBARRIER;
+    // ---- phase 2 (concurrent): fused proj_finish x3 ----
+    encAtFinish(e, 8192, AT_OFF_QF, 0, 1);
+    encAtFinish(e, 512, AT_OFF_K, 0, 2);
+    encAtFinish(e, 512, AT_OFF_V, 0, 3);
+    if (at_stage() == 1) goto finish;
+    ATBARRIER;
+    // ---- phase 3: per-head q/k RMS norm -> Qn/Kn (I128) ----
+    [e setComputePipelineState:pAtQknorm];
+    [e setBuffer:bAtQ offset:0 atIndex:0];
+    [e setBuffer:bAtRegs offset:0 atIndex:1];
+    [e setBuffer:wl offset:0 atIndex:2];
+    [e setBuffer:bAtQn offset:0 atIndex:3];
+    [e setBuffer:bAtKn offset:0 atIndex:4];
+    [e dispatchThreadgroups:MTLSizeMake(18, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    if (at_stage() == 2) goto finish;
+    ATBARRIER;
+    // ---- phase 4 (concurrent): I128 finish -> (qn_q, qn_s) and (kn_q, kn_s), shift 44 ----
+    encAtFinq(e, bAtQn, bAtQnQ, 4096, 5, 44);
+    encAtFinq(e, bAtKn, bAtKnQ, 512, 6, 44);
+    if (at_stage() == 3) goto finish;
+    ATBARRIER;
+    // ---- phase 5: RoPE in place on the A24 ints ----
+    [e setComputePipelineState:pAtRope];
+    [e setBuffer:bAtQnQ offset:0 atIndex:0];
+    [e setBuffer:bAtKnQ offset:0 atIndex:1];
+    [e setBuffer:bAtCos offset:0 atIndex:2];
+    [e setBuffer:bAtSin offset:0 atIndex:3];
+    [e setBytes:&rp length:sizeof(rp) atIndex:4];
+    [e dispatchThreads:MTLSizeMake(576, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+    if (at_stage() == 4) goto finish;
+    ATBARRIER;
+    // ---- phase 6: KV append into the resident cache (+ cq) ----
+    [e setComputePipelineState:pAtKv];
+    [e setBuffer:bAtKnQ offset:0 atIndex:0];
+    [e setBuffer:bAtQ offset:0 atIndex:1];
+    [e setBuffer:bAtRegs offset:0 atIndex:2];
+    [e setBuffer:bAtK[t->layer] offset:0 atIndex:3];
+    [e setBuffer:bAtV[t->layer] offset:0 atIndex:4];
+    [e setBytes:&rp length:sizeof(rp) atIndex:5];
+    [e dispatchThreads:MTLSizeMake(512, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+    if (at_stage() == 5) goto finish;
+    ATBARRIER;
+    // ---- phase 7: attention core (16 heads) ----
+    {
+        struct { unsigned tlen, kvmax, p0, p1; } cp = { t->pos + 1, gAtSmax, 0, 0 };
+        [e setComputePipelineState:pAtCore];
+        [e setBuffer:bAtQnQ offset:0 atIndex:0];
+        [e setBuffer:bAtK[t->layer] offset:0 atIndex:1];
+        [e setBuffer:bAtV[t->layer] offset:0 atIndex:2];
+        [e setBuffer:bAtQ offset:0 atIndex:3];
+        [e setBuffer:bAtRegs offset:0 atIndex:4];
+        [e setBuffer:bAtSig offset:0 atIndex:5];
+        [e setBuffer:bAtExpn offset:0 atIndex:6];
+        [e setBuffer:bAtScr offset:0 atIndex:7];
+        [e setBuffer:bAtEs offset:0 atIndex:8];
+        [e setBuffer:bAtAtt offset:0 atIndex:9];
+        [e setBytes:&cp length:sizeof(cp) atIndex:10];
+        [e dispatchThreadgroups:MTLSizeMake(16, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    }
+    if (at_stage() == 6) goto finish;
+    ATBARRIER;
+    // ---- phase 8: I128 finish -> (at_q, at_s), shift 32 ----
+    encAtFinq(e, bAtAtt, bAtAtq, 4096, 7, 32);
+    if (at_stage() == 7) goto finish;
+    ATBARRIER;
+    // ---- phase 9: attn_output GEMM ----
+    encAtGemm(e, t->ty[3], t->ptr[3], t->len[3], 2048, 16, bAtAtq, AT_OFF_OUT);
+    ATBARRIER;
+    // ---- phase 10: final fused finish -> (mq, ms) ----
+    encAtFinish(e, 2048, AT_OFF_OUT, 7, 9);
+    finish:
+    [e endEncoding];
+    [cb commit];
+    [cb waitUntilCompleted];
+    if (cb.status == MTLCommandBufferStatusError) { fprintf(stderr, "qi35at cb error: %s\n", cb.error.description.UTF8String); return -1; }
+    memcpy(mq_out, (char *)bAtQ.contents + AT_OFF_OUT * 4, 2048 * 4);
+    memcpy(ms16_out, (char *)bAtRegs.contents + 9 * 16, 16);
+    return 0;
+}
+
+void qi35_at_debug(unsigned char *qn, unsigned char *kn, int *qnq, int *knq,
+                   unsigned char *att, int *atq, unsigned char *regs,
+                   unsigned char *scr, unsigned char *es, unsigned long long tlen) {
+    memcpy(qn, bAtQn.contents, 4096 * 16);
+    memcpy(kn, bAtKn.contents, 512 * 16);
+    memcpy(qnq, bAtQnQ.contents, 4096 * 4);
+    memcpy(knq, bAtKnQ.contents, 512 * 4);
+    memcpy(att, bAtAtt.contents, 4096 * 16);
+    memcpy(atq, bAtAtq.contents, 4096 * 4);
+    memcpy(regs, bAtRegs.contents, 256 * 16);
+    for (unsigned h = 0; h < 16; h++) {
+        memcpy(scr + (unsigned long long)h * tlen * 16, (char *)bAtScr.contents + (unsigned long long)h * gAtSmax * 16, tlen * 16);
+        memcpy(es + (unsigned long long)h * tlen * 16, (char *)bAtEs.contents + (unsigned long long)h * gAtSmax * 16, tlen * 16);
+    }
+}
diff --git a/docs/evidence/qi35_metal_dn.m b/docs/evidence/qi35_metal_dn.m
new file mode 100644
index 0000000000000000000000000000000000000000..e1497413481b16e1a071bc9f57b9fee2b55d5c91
--- /dev/null
+++ b/docs/evidence/qi35_metal_dn.m
@@ -0,0 +1,410 @@
+// qi35_metal_dn — QI35-5 v3 Phase B: the ENTIRE DeltaNet block on-device in ONE commit.
+// Bit-exact contract: every kernel reproduces the frozen CPU semantics of qi35_model.rs
+// deltanet() exactly — I128 two-word arithmetic, RNE via (x + 2^(s-1)) >> s arithmetic shifts,
+// floor division (div_euclid), Newton isqrt with the identical iteration sequence, LUT indexing
+// with the identical clamp, and column-local recurrence (no cross-thread reductions except
+// exact integer trees, which are order-free by associativity).
+// State (S [32*128*128] i64 Q24, conv ring [3*8192] i64 Q16) lives in Rust page-aligned memory
+// wrapped as no-copy MTLBuffers: GPU updates in place, CPU fallback/shadow/state_root read the
+// very same bytes. Compiled together with qi35_metal_shim.m + qi35_metal_moe.m.
+#import <Foundation/Foundation.h>
+#import <Metal/Metal.h>
+
+// from qi35_metal_shim.m
+extern id<MTLDevice> qi35_dev(void);
+extern id<MTLCommandQueue> qi35_queue(void);
+extern id<MTLBuffer> qi35_buffer_for(const void *w_ptr, unsigned long long w_len, unsigned long long *delta_out);
+// from qi35_metal_moe.m (created in qi35_moe_init; dn init runs after moe init)
+extern id<MTLComputePipelineState> qi35_pFinish;
+extern id<MTLComputePipelineState> qi35_pGemm4, qi35_pGemm6;
+
+static id<MTLComputePipelineState> pDnScal, pDnConv, pDnL2, pDnRecur, pDnGnorm, pDnFinq;
+id<MTLComputePipelineState> qi35_pFinq128; // exported for qi35_metal_at.m (shift-parameterized I128 finish)
+static id<MTLBuffer> bDnXq, bDnRegs, bDnAcc, bDnColsq, bDnResc, bDnQ;
+static id<MTLBuffer> bDnConvs, bDnQk, bDnO24, bDnY, bDnYq, bDnSel;
+static id<MTLBuffer> bDnSig, bDnSpl, bDnGam;
+static id<MTLBuffer> bDnW[64], bDnS[64], bDnRing[64];
+
+// Row layout inside the shared ACC/COLSQ/RESC/Q buffers:
+//   [0..8192)      qkv        (attn_qkv,  k=2048, nsb=8)
+//   [8192..12288)  z          (attn_gate, k=2048, nsb=8)
+//   [12288..12320) beta       (ssm_beta,  k=2048, nsb=8)
+//   [12320..12352) alpha      (ssm_alpha, k=2048, nsb=8)
+//   [12352..14400) out        (ssm_out,   k=4096, nsb=16)
+// REGS (I128 slots): 0=xs  1=s_qkv  2=s_z  3=s_b  4=s_a  5=ys  6=s_out(ms)
+//                    8..40=beta16[h]  40..72=gam30[h]
+#define DN_ROWS_TOTAL 14400
+#define DN_OFF_QKV 0
+#define DN_OFF_Z 8192
+#define DN_OFF_B 12288
+#define DN_OFF_A 12320
+#define DN_OFF_OUT 12352
+
+static NSString *const kDnSrc = @""
+"#include <metal_stdlib>\n"
+"using namespace metal;\n"
+"struct I128 { ulong lo; long hi; };\n"
+"static inline I128 mk64(long v) { I128 r; r.lo = (ulong)v; r.hi = v < 0 ? -1 : 0; return r; }\n"
+"static inline I128 addi(I128 a, I128 b) { I128 r; r.lo = a.lo + b.lo; r.hi = a.hi + b.hi + (long)(r.lo < a.lo ? 1 : 0); return r; }\n"
+"static inline I128 negi(I128 a) { I128 r; r.lo = ~a.lo; r.hi = ~a.hi; r.lo += 1; if (r.lo == 0) r.hi += 1; return r; }\n"
+"static inline bool isneg(I128 a) { return a.hi < 0; }\n"
+"static inline bool lti(I128 a, I128 b) { return a.hi < b.hi || (a.hi == b.hi && a.lo < b.lo); }\n"
+"static inline bool ltu(I128 a, I128 b) { ulong ah = (ulong)a.hi, bh = (ulong)b.hi; return ah < bh || (ah == bh && a.lo < b.lo); }\n"
+"static inline I128 shli(I128 a, uint s) { I128 r; if (s == 0) return a; if (s >= 64) { r.lo = 0; r.hi = (long)(a.lo << (s - 64)); } else { r.lo = a.lo << s; r.hi = (long)(((ulong)a.hi << s) | (a.lo >> (64 - s))); } return r; }\n"
+"static inline I128 shri(I128 a, uint s) { I128 r; if (s == 0) return a; if (s >= 64) { r.lo = (ulong)(a.hi >> (s - 64)); r.hi = a.hi >> 63; } else { r.lo = (a.lo >> s) | ((ulong)a.hi << (64 - s)); r.hi = a.hi >> s; } return r; }\n"
+"static inline I128 mag(I128 a) { return isneg(a) ? negi(a) : a; }\n"
+"static inline I128 mulmag_u64(I128 a, ulong b) { I128 r; r.lo = a.lo * b; ulong h = mulhi(a.lo, b); r.hi = (long)(h + (ulong)a.hi * b); return r; }\n"
+"static inline I128 muli_u64(I128 a, ulong b) { bool n = isneg(a); I128 m = mulmag_u64(mag(a), b); return n ? negi(m) : m; }\n"
+"static inline I128 muli_i64(I128 a, long b) { bool nb = b < 0; ulong ub = (ulong)(nb ? -b : b); I128 m = muli_u64(a, ub); return nb ? negi(m) : m; }\n"
+"static inline I128 divmag(I128 num, I128 den, thread I128 *rem_out) {\n"
+"    I128 q; q.lo = 0; q.hi = 0; I128 r; r.lo = 0; r.hi = 0;\n"
+"    for (int i = 127; i >= 0; i--) {\n"
+"        r = shli(r, 1);\n"
+"        ulong bit = (i >= 64) ? (((ulong)num.hi >> (i - 64)) & 1) : ((num.lo >> i) & 1);\n"
+"        r.lo |= bit;\n"
+"        if (!ltu(r, den)) { r = addi(r, negi(den)); if (i >= 64) q.hi |= (long)(1ul << (i - 64)); else q.lo |= (1ul << i); }\n"
+"    }\n"
+"    if (rem_out) *rem_out = r;\n"
+"    return q;\n"
+"}\n"
+"static inline I128 fdivi(I128 num, I128 den) {\n"
+"    bool n = isneg(num); I128 r; I128 q = divmag(mag(num), mag(den), &r);\n"
+"    if (n && (r.lo | (ulong)r.hi) != 0) { q = addi(q, mk64(1)); return negi(q); }\n"
+"    return n ? negi(q) : q;\n"
+"}\n"
+"static inline I128 halfc() { I128 h; h.lo = 1ul << 59; h.hi = 0; return h; }\n"
+"// to_fix(a, s, 16) = rne(a*s, 44) with a fitting i64 and s an I128 Q60 scale\n"
+"static inline long tofix16(I128 s, long a) { return (long)(shri(addi(muli_i64(s, a), mk64(1l << 43)), 44).lo); }\n"
+"// sig LUT index: clamp(rne(x, 7) + 8192, 0, 16383) — x fits i64\n"
+"static inline long sigidx(long x) { return clamp(((x + 64) >> 7) + 8192, 0l, 16383l); }\n"
+"// Newton isqrt, identical iteration to Rust isqrt for inputs < 2^63\n"
+"static inline ulong isqrt64(ulong n) {\n"
+"    if (n == 0) return 0;\n"
+"    ulong x = n, y = (x + 1) / 2;\n"
+"    while (y < x) { x = y; y = (x + n / x) / 2; }\n"
+"    return x;\n"
+"}\n"
+"// ---- 1. per-head scalars: beta16 = sig(to_fix(bq,s_b,16)), gam30 = gamma(rne(-a30*softplus(a16),35)) ----\n"
+"kernel void k_dn_scalars(device const int* Q [[buffer(0)]], device I128* REGS [[buffer(1)]],\n"
+"                         device const long* SIG [[buffer(2)]], device const long* SPL [[buffer(3)]],\n"
+"                         device const long* GAM [[buffer(4)]], device const long* DT [[buffer(5)]],\n"
+"                         device const long* A30 [[buffer(6)]], uint gid [[thread_position_in_grid]]) {\n"
+"    if (gid >= 32) return;\n"
+"    long b16 = tofix16(REGS[3], (long)Q[12288 + gid]);\n"
+"    REGS[8 + gid] = mk64(SIG[sigidx(b16)]);\n"
+"    long a16 = tofix16(REGS[4], (long)Q[12320 + gid]) + DT[gid];\n"
+"    long spl;\n"
+"    if (a16 > (20l << 16)) spl = a16;\n"
+"    else spl = SPL[sigidx(a16)];\n"
+"    I128 gprod = muli_i64(mk64(A30[gid]), spl);\n"
+"    long gidx = (long)(shri(addi(negi(gprod), mk64(1l << 34)), 35).lo);\n"
+"    long g30 = 0;\n"
+"    if (gidx <= 32768) g30 = GAM[max(gidx, 0l)];\n"
+"    REGS[40 + gid] = mk64(g30);\n"
+"}\n"
+"// ---- 2. conv: u = to_fix(qkv_q, s_qkv, 16); 4-tap dot Q30; silu; ring shift (channel-local) ----\n"
+"kernel void k_dn_conv(device const int* Q [[buffer(0)]], device I128* REGS [[buffer(1)]],\n"
+"                      device const long* W [[buffer(2)]], device long* RING [[buffer(3)]],\n"
+"                      device long* CONVS [[buffer(4)]], device const long* SIG [[buffer(5)]],\n"
+"                      uint gid [[thread_position_in_grid]]) {\n"
+"    if (gid >= 8192) return;\n"
+"    I128 s = REGS[1];\n"
+"    long u = tofix16(s, (long)Q[gid]);\n"
+"    long r0 = RING[gid], r1 = RING[8192 + gid], r2 = RING[16384 + gid];\n"
+"    I128 acc = muli_i64(mk64(W[gid * 4 + 0]), r0);\n"
+"    acc = addi(acc, muli_i64(mk64(W[gid * 4 + 1]), r1));\n"
+"    acc = addi(acc, muli_i64(mk64(W[gid * 4 + 2]), r2));\n"
+"    acc = addi(acc, muli_i64(mk64(W[gid * 4 + 3]), u));\n"
+"    long raw = (long)(shri(addi(acc, mk64(1l << 29)), 30).lo);\n"
+"    CONVS[gid] = (raw * SIG[sigidx(raw)]) >> 16;\n"
+"    RING[gid] = r1; RING[8192 + gid] = r2; RING[16384 + gid] = u;\n"
+"}\n"
+"// ---- 3. L2 norm of q/k segments: n = isqrt(sum sq).max(1); out = fdiv(seg*2^21 + n, 2n) ----\n"
+"// tg 0..15 = q (convs[tg*128..]), tg 16..31 = k (convs[2048 + (tg-16)*128..])\n"
+"kernel void k_dn_l2(device const long* CONVS [[buffer(0)]], device long* QK [[buffer(1)]],\n"
+"                    uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]]) {\n"
+"    threadgroup ulong sh[128];\n"
+"    uint base = (tg < 16) ? (tg * 128) : (2048 + (tg - 16) * 128);\n"
+"    long v = CONVS[base + tid];\n"
+"    sh[tid] = (ulong)(v * v);\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = 64; s > 0; s >>= 1) { if (tid < s) sh[tid] += sh[tid + s]; threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    long n = (long)max(isqrt64(sh[0]), 1ul);\n"
+"    long num = v * (1l << 21) + n;\n"
+"    long den = 2 * n;\n"
+"    long q = num / den;\n"
+"    if (num % den != 0 && num < 0) q -= 1;\n"
+"    QK[tg * 128 + tid] = q;\n"
+"}\n"
+"// ---- 4. recurrence: one threadgroup per v-head, one thread per column j (column-local) ----\n"
+"kernel void k_dn_recur(device long* S [[buffer(0)]], device const long* QK [[buffer(1)]],\n"
+"                       device const long* CONVS [[buffer(2)]], device I128* REGS [[buffer(3)]],\n"
+"                       device long* O24 [[buffer(4)]],\n"
+"                       uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]]) {\n"
+"    threadgroup long kv[128];\n"
+"    threadgroup long qv[128];\n"
+"    uint kh = tg % 16;\n"
+"    qv[tid] = QK[kh * 128 + tid];\n"
+"    kv[tid] = QK[(16 + kh) * 128 + tid];\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    long g = (long)REGS[40 + tg].lo;\n"
+"    long b = (long)REGS[8 + tg].lo;\n"
+"    device long* s = S + (ulong)tg * 128 * 128;\n"
+"    uint j = tid;\n"
+"    for (uint i = 0; i < 128; i++) {\n"
+"        I128 t = muli_i64(mk64(g), s[i * 128 + j]);\n"
+"        s[i * 128 + j] = (long)(shri(addi(t, mk64(1l << 29)), 30).lo);\n"
+"    }\n"
+"    I128 sk; sk.lo = 0; sk.hi = 0;\n"
+"    for (uint i = 0; i < 128; i++) sk = addi(sk, muli_i64(mk64(kv[i]), s[i * 128 + j]));\n"
+"    sk = shri(addi(sk, mk64(1l << 19)), 20);\n"
+"    long v16 = CONVS[4096 + tg * 128 + j];\n"
+"    I128 dv = addi(shli(mk64(v16), 8), negi(sk));\n"
+"    long dl = (long)(shri(addi(muli_i64(dv, b), mk64(1l << 15)), 16).lo);\n"
+"    for (uint i = 0; i < 128; i++) {\n"
+"        I128 upd = shri(addi(muli_i64(mk64(dl), kv[i]), mk64(1l << 19)), 20);\n"
+"        s[i * 128 + j] += (long)upd.lo;\n"
+"    }\n"
+"    I128 acc; acc.lo = 0; acc.hi = 0;\n"
+"    for (uint i = 0; i < 128; i++) acc = addi(acc, muli_i64(mk64(qv[i]), s[i * 128 + j]));\n"
+"    I128 raw = shri(addi(acc, mk64(1l << 19)), 20);\n"
+"    I128 o = shri(addi(muli_u64(raw, 94906266ul), mk64(1l << 29)), 30);\n"
+"    O24[tg * 128 + j] = (long)o.lo;\n"
+"}\n"
+"// ---- 5. gated norm: per-head rms (EPS_Q48, isqrt(2^88/mean)) * silu(z16) -> y (I128) ----\n"
+"kernel void k_dn_gnorm(device const long* O24 [[buffer(0)]], device const long* NRM [[buffer(1)]],\n"
+"                       device const int* Q [[buffer(2)]], device I128* REGS [[buffer(3)]],\n"
+"                       device const long* SIG [[buffer(4)]], device I128* Y [[buffer(5)]],\n"
+"                       uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]]) {\n"
+"    threadgroup I128 sh[128];\n"
+"    long v = O24[tg * 128 + tid];\n"
+"    sh[tid] = muli_i64(mk64(v), v);\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = 64; s > 0; s >>= 1) { if (tid < s) sh[tid] = addi(sh[tid], sh[tid + s]); threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    I128 mean = addi(shri(sh[0], 7), mk64(281474977l + 1l));\n"
+"    I128 qd = divmag(shli(mk64(1), 88), mean, 0);\n"
+"    ulong inv = isqrt64(qd.lo);\n"
+"    I128 t = muli_u64(mk64(v), inv);\n"
+"    t = muli_i64(t, NRM[tid]);\n"
+"    I128 normed = shri(addi(t, mk64(1l << 29)), 30);\n"
+"    long z16 = tofix16(REGS[2], (long)Q[8192 + tg * 128 + tid]);\n"
+"    long sil = (z16 * SIG[sigidx(z16)]) >> 16;\n"
+"    Y[tg * 128 + tid] = muli_i64(normed, sil);\n"
+"}\n"
+"// ---- 6. fused finish over I128 vector: amax -> aq -> ys = rne(sfrom(amax, 2^60), shift) ----\n"
+"// shift parameterized for reuse (dn ys: 60; attention qn_s/kn_s: 44; at_s: 32)\n"
+"struct FQ { uint n; uint ys_slot; uint shift; uint pad1; };\n"
+"kernel void k_finq128(device const I128* Y [[buffer(0)]], device int* YQ [[buffer(1)]],\n"
+"                      device I128* REGS [[buffer(2)]], constant FQ& p [[buffer(3)]],\n"
+"                      uint tid [[thread_position_in_threadgroup]], uint tpg [[threads_per_threadgroup]]) {\n"
+"    threadgroup I128 sh[256];\n"
+"    threadgroup I128 tg_amax;\n"
+"    I128 mymax; mymax.lo = 0; mymax.hi = 0;\n"
+"    for (uint i = tid; i < p.n; i += tpg) { I128 a = mag(Y[i]); if (lti(mymax, a)) mymax = a; }\n"
+"    sh[tid] = mymax;\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = tpg / 2; s > 0; s >>= 1) { if (tid < s) { if (lti(sh[tid], sh[tid + s])) sh[tid] = sh[tid + s]; } threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    if (tid == 0) { I128 a = sh[0]; if (a.lo == 0 && a.hi == 0) a = mk64(1); tg_amax = a; }\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    I128 amax = tg_amax;\n"
+"    const ulong ALVL2 = ((1ul << 23) - 1) * 2;\n"
+"    for (uint i = tid; i < p.n; i += tpg) {\n"
+"        I128 x = Y[i];\n"
+"        I128 num = muli_u64(x, ALVL2);\n"
+"        I128 sg;\n"
+"        if (isneg(x)) sg = negi(amax);\n"
+"        else if ((x.lo | (ulong)x.hi) != 0) sg = amax;\n"
+"        else { sg.lo = 0; sg.hi = 0; }\n"
+"        num = addi(num, sg);\n"
+"        YQ[i] = (int)fdivi(num, shli(amax, 1)).lo;\n"
+"    }\n"
+"    if (tid == 0) {\n"
+"        I128 ra; I128 qa = divmag(amax, mk64((1l << 23) - 1), &ra);\n"
+"        I128 s0 = addi(shli(qa, 60), divmag(shli(ra, 60), mk64((1l << 23) - 1), 0));\n"
+"        REGS[p.ys_slot] = shri(addi(s0, shli(mk64(1), p.shift - 1)), p.shift);\n"
+"    }\n"
+"}\n";
+
+int qi35_dn_init(const long *sig, const long *softplus, const long *gamma) {
+    id<MTLDevice> dev = qi35_dev();
+    NSError *err = nil;
+    id<MTLLibrary> lib = [dev newLibraryWithSource:kDnSrc options:nil error:&err];
+    if (!lib) { fprintf(stderr, "qi35dn: %s\n", err.description.UTF8String); return -1; }
+    #define DPIPE(v, n) v = [dev newComputePipelineStateWithFunction:[lib newFunctionWithName:@n] error:&err]; if (!v) { fprintf(stderr, "qi35dn pipe %s\n", n); return -2; }
+    DPIPE(pDnScal, "k_dn_scalars"); DPIPE(pDnConv, "k_dn_conv"); DPIPE(pDnL2, "k_dn_l2");
+    DPIPE(pDnRecur, "k_dn_recur"); DPIPE(pDnGnorm, "k_dn_gnorm"); DPIPE(pDnFinq, "k_finq128");
+    qi35_pFinq128 = pDnFinq;
+    bDnSig = [dev newBufferWithBytes:sig length:16384 * 8 options:MTLResourceStorageModeShared];
+    bDnSpl = [dev newBufferWithBytes:softplus length:16384 * 8 options:MTLResourceStorageModeShared];
+    bDnGam = [dev newBufferWithBytes:gamma length:32769 * 8 options:MTLResourceStorageModeShared];
+    bDnXq = [dev newBufferWithLength:2048 * 4 options:MTLResourceStorageModeShared];
+    bDnRegs = [dev newBufferWithLength:256 * 16 options:MTLResourceStorageModeShared];
+    bDnAcc = [dev newBufferWithLength:DN_ROWS_TOTAL * 24 options:MTLResourceStorageModeShared];
+    bDnColsq = [dev newBufferWithLength:DN_ROWS_TOTAL * 16 options:MTLResourceStorageModeShared];
+    bDnResc = [dev newBufferWithLength:DN_ROWS_TOTAL * 8 options:MTLResourceStorageModeShared];
+    bDnQ = [dev newBufferWithLength:DN_ROWS_TOTAL * 4 options:MTLResourceStorageModeShared];
+    bDnConvs = [dev newBufferWithLength:8192 * 8 options:MTLResourceStorageModeShared];
+    bDnQk = [dev newBufferWithLength:4096 * 8 options:MTLResourceStorageModeShared];
+    bDnO24 = [dev newBufferWithLength:4096 * 8 options:MTLResourceStorageModeShared];
+    bDnY = [dev newBufferWithLength:4096 * 16 options:MTLResourceStorageModeShared];
+    bDnYq = [dev newBufferWithLength:4096 * 4 options:MTLResourceStorageModeShared];
+    bDnSel = [dev newBufferWithLength:8 * 4 options:MTLResourceStorageModeShared];
+    memset(bDnSel.contents, 0, 8 * 4);
+    return 0;
+}
+
+void qi35_dn_upload_layer(unsigned layer, const long *w30, const long *nrm, const long *dt16, const long *a30) {
+    // one buffer per layer: w30[32768] | ssm_norm[128] | dt16[32] | a30[32]
+    id<MTLBuffer> b = [qi35_dev() newBufferWithLength:(32768 + 128 + 32 + 32) * 8 options:MTLResourceStorageModeShared];
+    memcpy(b.contents, w30, 32768 * 8);
+    memcpy((char *)b.contents + 32768 * 8, nrm, 128 * 8);
+    memcpy((char *)b.contents + (32768 + 128) * 8, dt16, 32 * 8);
+    memcpy((char *)b.contents + (32768 + 160) * 8, a30, 32 * 8);
+    bDnW[layer] = b;
+}
+
+int qi35_dn_bind_state(unsigned layer, void *s_ptr, unsigned long long s_len, void *conv_ptr, unsigned long long conv_len) {
+    id<MTLDevice> dev = qi35_dev();
+    bDnS[layer] = [dev newBufferWithBytesNoCopy:s_ptr length:s_len options:MTLResourceStorageModeShared deallocator:nil];
+    bDnRing[layer] = [dev newBufferWithBytesNoCopy:conv_ptr length:conv_len options:MTLResourceStorageModeShared deallocator:nil];
+    if (!bDnS[layer] || !bDnRing[layer]) { fprintf(stderr, "qi35dn: no-copy state buffer failed layer %u\n", layer); return -1; }
+    return 0;
+}
+
+typedef struct { const void *ptr[5]; unsigned long long len[5]; unsigned ty[5]; unsigned layer; } DnTensors;
+
+static void encDnGemm(id<MTLComputeCommandEncoder> e, unsigned ty, const void *ptr, unsigned long long len,
+                      unsigned rows, unsigned nsb, id<MTLBuffer> xbuf, unsigned long accOff) {
+    unsigned long long d;
+    id<MTLBuffer> wb = qi35_buffer_for(ptr, len, &d);
+    struct MPh { unsigned nsb, rows, nseg, fexp; unsigned long long toff; unsigned segsexp, which, segbase, pad; } mp =
+        { nsb, rows, 1, 0, d, 0, 0, 0, 0 };
+    [e setComputePipelineState:(ty == 12 ? qi35_pGemm4 : qi35_pGemm6)];
+    [e setBuffer:wb offset:0 atIndex:0];
+    [e setBuffer:xbuf offset:0 atIndex:1];
+    [e setBuffer:bDnAcc offset:accOff * 24 atIndex:2];
+    [e setBytes:&mp length:sizeof(mp) atIndex:3];
+    [e setBuffer:bDnSel offset:0 atIndex:4];
+    [e dispatchThreads:MTLSizeMake(rows, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+}
+
+static void encDnFinish(id<MTLComputeCommandEncoder> e, unsigned rows, unsigned long off, unsigned xs_slot, unsigned sout) {
+    struct { unsigned rows, xs_slot, xs_per_seg, sout_base; } ff = { rows, xs_slot, 0, sout };
+    [e setComputePipelineState:qi35_pFinish];
+    [e setBuffer:bDnAcc offset:off * 24 atIndex:0];
+    [e setBuffer:bDnColsq offset:off * 16 atIndex:1];
+    [e setBuffer:bDnResc offset:off * 8 atIndex:2];
+    [e setBuffer:bDnQ offset:off * 4 atIndex:3];
+    [e setBuffer:bDnRegs offset:0 atIndex:4];
+    [e setBytes:&ff length:sizeof(ff) atIndex:5];
+    [e dispatchThreadgroups:MTLSizeMake(1, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+}
+
+static int dn_stage(void) {
+    static int st = -1;
+    if (st < 0) { const char *e = getenv("QI35_DN_STAGE"); st = e ? atoi(e) : 0; }
+    return st;
+}
+
+int qi35_dn_run(const DnTensors *t, const int *xq, const unsigned char *xs16, int *mq_out, unsigned char *ms16_out) {
+    memcpy(bDnXq.contents, xq, 2048 * 4);
+    memcpy(bDnRegs.contents, xs16, 16); // slot 0 = xs
+    id<MTLBuffer> wl = bDnW[t->layer];
+    id<MTLCommandBuffer> cb = [qi35_queue() commandBuffer];
+    id<MTLComputeCommandEncoder> e = [cb computeCommandEncoderWithDispatchType:MTLDispatchTypeConcurrent];
+    #define DNBARRIER [e memoryBarrierWithScope:MTLBarrierScopeBuffers]
+
+    // ---- phase 1 (concurrent): the four input GEMMs ----
+    encDnGemm(e, t->ty[0], t->ptr[0], t->len[0], 8192, 8, bDnXq, DN_OFF_QKV);
+    encDnGemm(e, t->ty[1], t->ptr[1], t->len[1], 4096, 8, bDnXq, DN_OFF_Z);
+    encDnGemm(e, t->ty[2], t->ptr[2], t->len[2], 32, 8, bDnXq, DN_OFF_B);
+    encDnGemm(e, t->ty[3], t->ptr[3], t->len[3], 32, 8, bDnXq, DN_OFF_A);
+    DNBARRIER;
+    // ---- phase 2 (concurrent): fused proj_finish x4 ----
+    encDnFinish(e, 8192, DN_OFF_QKV, 0, 1);
+    encDnFinish(e, 4096, DN_OFF_Z, 0, 2);
+    encDnFinish(e, 32, DN_OFF_B, 0, 3);
+    encDnFinish(e, 32, DN_OFF_A, 0, 4);
+    if (dn_stage() == 1) goto finish;
+    DNBARRIER;
+    // ---- phase 3 (concurrent): per-head scalars + conv/ring ----
+    [e setComputePipelineState:pDnScal];
+    [e setBuffer:bDnQ offset:0 atIndex:0];
+    [e setBuffer:bDnRegs offset:0 atIndex:1];
+    [e setBuffer:bDnSig offset:0 atIndex:2];
+    [e setBuffer:bDnSpl offset:0 atIndex:3];
+    [e setBuffer:bDnGam offset:0 atIndex:4];
+    [e setBuffer:wl offset:(32768 + 128) * 8 atIndex:5];
+    [e setBuffer:wl offset:(32768 + 160) * 8 atIndex:6];
+    [e dispatchThreads:MTLSizeMake(32, 1, 1) threadsPerThreadgroup:MTLSizeMake(32, 1, 1)];
+    [e setComputePipelineState:pDnConv];
+    [e setBuffer:bDnQ offset:0 atIndex:0];
+    [e setBuffer:bDnRegs offset:0 atIndex:1];
+    [e setBuffer:wl offset:0 atIndex:2];
+    [e setBuffer:bDnRing[t->layer] offset:0 atIndex:3];
+    [e setBuffer:bDnConvs offset:0 atIndex:4];
+    [e setBuffer:bDnSig offset:0 atIndex:5];
+    [e dispatchThreads:MTLSizeMake(8192, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    if (dn_stage() == 2) goto finish;
+    DNBARRIER;
+    // ---- phase 4: L2 norm of q/k ----
+    [e setComputePipelineState:pDnL2];
+    [e setBuffer:bDnConvs offset:0 atIndex:0];
+    [e setBuffer:bDnQk offset:0 atIndex:1];
+    [e dispatchThreadgroups:MTLSizeMake(32, 1, 1) threadsPerThreadgroup:MTLSizeMake(128, 1, 1)];
+    DNBARRIER;
+    // ---- phase 5: recurrence (state in place) ----
+    [e setComputePipelineState:pDnRecur];
+    [e setBuffer:bDnS[t->layer] offset:0 atIndex:0];
+    [e setBuffer:bDnQk offset:0 atIndex:1];
+    [e setBuffer:bDnConvs offset:0 atIndex:2];
+    [e setBuffer:bDnRegs offset:0 atIndex:3];
+    [e setBuffer:bDnO24 offset:0 atIndex:4];
+    [e dispatchThreadgroups:MTLSizeMake(32, 1, 1) threadsPerThreadgroup:MTLSizeMake(128, 1, 1)];
+    if (dn_stage() == 3) goto finish;
+    DNBARRIER;
+    // ---- phase 6: gated norm -> y (I128) ----
+    [e setComputePipelineState:pDnGnorm];
+    [e setBuffer:bDnO24 offset:0 atIndex:0];
+    [e setBuffer:wl offset:32768 * 8 atIndex:1];
+    [e setBuffer:bDnQ offset:0 atIndex:2];
+    [e setBuffer:bDnRegs offset:0 atIndex:3];
+    [e setBuffer:bDnSig offset:0 atIndex:4];
+    [e setBuffer:bDnY offset:0 atIndex:5];
+    [e dispatchThreadgroups:MTLSizeMake(32, 1, 1) threadsPerThreadgroup:MTLSizeMake(128, 1, 1)];
+    DNBARRIER;
+    // ---- phase 7: I128 finish (yq + ys) ----
+    {
+        struct { unsigned n, ys_slot, shift, p1; } fq = { 4096, 5, 60, 0 };
+        [e setComputePipelineState:pDnFinq];
+        [e setBuffer:bDnY offset:0 atIndex:0];
+        [e setBuffer:bDnYq offset:0 atIndex:1];
+        [e setBuffer:bDnRegs offset:0 atIndex:2];
+        [e setBytes:&fq length:sizeof(fq) atIndex:3];
+        [e dispatchThreadgroups:MTLSizeMake(1, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    }
+    if (dn_stage() == 4) goto finish;
+    DNBARRIER;
+    // ---- phase 8: ssm_out GEMM ----
+    encDnGemm(e, t->ty[4], t->ptr[4], t->len[4], 2048, 16, bDnYq, DN_OFF_OUT);
+    DNBARRIER;
+    // ---- phase 9: final fused finish -> (mq, ms) ----
+    encDnFinish(e, 2048, DN_OFF_OUT, 5, 6);
+    finish:
+    [e endEncoding];
+    [cb commit];
+    [cb waitUntilCompleted];
+    if (cb.status == MTLCommandBufferStatusError) { fprintf(stderr, "qi35dn cb error: %s\n", cb.error.description.UTF8String); return -1; }
+    memcpy(mq_out, (char *)bDnQ.contents + DN_OFF_OUT * 4, 2048 * 4);
+    memcpy(ms16_out, (char *)bDnRegs.contents + 6 * 16, 16);
+    return 0;
+}
+
+void qi35_dn_debug(long *convs, long *qk, long *o24, unsigned char *y16, int *yq, unsigned char *regs) {
+    memcpy(convs, bDnConvs.contents, 8192 * 8);
+    memcpy(qk, bDnQk.contents, 4096 * 8);
+    memcpy(o24, bDnO24.contents, 4096 * 8);
+    memcpy(y16, bDnY.contents, 4096 * 16);
+    memcpy(yq, bDnYq.contents, 4096 * 4);
+    memcpy(regs, bDnRegs.contents, 256 * 16);
+}
diff --git a/docs/evidence/qi35_metal_moe.m b/docs/evidence/qi35_metal_moe.m
new file mode 100644
index 0000000000000000000000000000000000000000..23f952bd156fe37f71aeac8ff4a48af48f93f11e
--- /dev/null
+++ b/docs/evidence/qi35_metal_moe.m
@@ -0,0 +1,746 @@
+// qi35_metal_moe — QI35-5 v3 Phase A: the ENTIRE MoE block on-device in ONE commit.
+// Bit-exact contract: every kernel reproduces the frozen CPU semantics exactly — I128 two-word
+// arithmetic, binary long division (floor semantics identical to Rust div_euclid), Q60 scale
+// algebra, LUT lookups, deterministic top-8 (desc value, tie -> low expert index).
+// Compiled together with qi35_metal_shim.m into libqi35metal.dylib.
+#import <Foundation/Foundation.h>
+#import <Metal/Metal.h>
+
+// from qi35_metal_shim.m
+extern id<MTLDevice> qi35_dev(void);
+extern id<MTLCommandQueue> qi35_queue(void);
+extern id<MTLBuffer> qi35_buffer_for(const void *w_ptr, unsigned long long w_len, unsigned long long *delta_out);
+
+static id<MTLComputePipelineState> pRouter, pTopk, pGemm4Exp, pGemm6Exp, pColsq, pRescale, pAqSeg, pSiluUp, pAmaxRaw, pCombine, pWeighted;
+static id<MTLBuffer> bSig, bExpn, bRouters[64];
+static id<MTLBuffer> bXq, bXregs, bSel, bLogits, bAccGU, bColsqGU, bRescGU, bQGU, bHm, bQHm, bAccDn, bColsqDn, bRescDn, bQDn, bTot, bMq;
+
+static NSString *const kMoeSrc = @""
+"#include <metal_stdlib>\n"
+"using namespace metal;\n"
+"struct I128 { ulong lo; long hi; };\n"
+"static inline I128 mk64(long v) { I128 r; r.lo = (ulong)v; r.hi = v < 0 ? -1 : 0; return r; }\n"
+"static inline I128 addi(I128 a, I128 b) { I128 r; r.lo = a.lo + b.lo; r.hi = a.hi + b.hi + (long)(r.lo < a.lo ? 1 : 0); return r; }\n"
+"static inline I128 negi(I128 a) { I128 r; r.lo = ~a.lo; r.hi = ~a.hi; r.lo += 1; if (r.lo == 0) r.hi += 1; return r; }\n"
+"static inline bool isneg(I128 a) { return a.hi < 0; }\n"
+"static inline bool lti(I128 a, I128 b) { return a.hi < b.hi || (a.hi == b.hi && a.lo < b.lo); }\n"
+"static inline bool ltu(I128 a, I128 b) { ulong ah = (ulong)a.hi, bh = (ulong)b.hi; return ah < bh || (ah == bh && a.lo < b.lo); }\n"
+"static inline I128 shli(I128 a, uint s) { I128 r; if (s == 0) return a; if (s >= 64) { r.lo = 0; r.hi = (long)(a.lo << (s - 64)); } else { r.lo = a.lo << s; r.hi = (long)(((ulong)a.hi << s) | (a.lo >> (64 - s))); } return r; }\n"
+"static inline I128 shri(I128 a, uint s) { I128 r; if (s == 0) return a; if (s >= 64) { r.lo = (ulong)(a.hi >> (s - 64)); r.hi = a.hi >> 63; } else { r.lo = (a.lo >> s) | ((ulong)a.hi << (64 - s)); r.hi = a.hi >> s; } return r; }\n"
+"static inline I128 mag(I128 a) { return isneg(a) ? negi(a) : a; }\n"
+"// magnitude(128) x u64 -> low 128 bits (caller guarantees fit)\n"
+"static inline I128 mulmag_u64(I128 a, ulong b) { I128 r; r.lo = a.lo * b; ulong h = mulhi(a.lo, b); r.hi = (long)(h + (ulong)a.hi * b); return r; }\n"
+"static inline I128 muli_u64(I128 a, ulong b) { bool n = isneg(a); I128 m = mulmag_u64(mag(a), b); return n ? negi(m) : m; }\n"
+"static inline I128 muli_i64(I128 a, long b) { bool nb = b < 0; ulong ub = (ulong)(nb ? -b : b); I128 m = muli_u64(a, ub); return nb ? negi(m) : m; }\n"
+"// unsigned 128/128 binary long division: returns floor(num/den), den != 0\n"
+"static inline I128 divmag(I128 num, I128 den, thread I128 *rem_out) {\n"
+"    I128 q; q.lo = 0; q.hi = 0; I128 r; r.lo = 0; r.hi = 0;\n"
+"    for (int i = 127; i >= 0; i--) {\n"
+"        r = shli(r, 1);\n"
+"        ulong bit = (i >= 64) ? (((ulong)num.hi >> (i - 64)) & 1) : ((num.lo >> i) & 1);\n"
+"        r.lo |= bit;\n"
+"        if (!ltu(r, den)) { r = addi(r, negi(den)); if (i >= 64) q.hi |= (long)(1ul << (i - 64)); else q.lo |= (1ul << i); }\n"
+"    }\n"
+"    if (rem_out) *rem_out = r;\n"
+"    return q;\n"
+"}\n"
+"// floor division (Rust div_euclid semantics for positive denominator)\n"
+"static inline I128 fdivi(I128 num, I128 den) {\n"
+"    bool n = isneg(num); I128 r; I128 q = divmag(mag(num), mag(den), &r);\n"
+"    if (n && (r.lo | (ulong)r.hi) != 0) { q = addi(q, mk64(1)); return negi(q); }\n"
+"    return n ? negi(q) : q;\n"
+"}\n"
+"static inline I128 halfc() { I128 h; h.lo = 1ul << 59; h.hi = 0; return h; }\n"
+"// apply(a, s) = (a*s + HALF) >> 60 with s fitting u64 (ratios/Q60 fragments)\n"
+"static inline I128 applyu(I128 a, ulong s) { return shri(addi(muli_u64(a, s), halfc()), 60); }\n"
+"// mul(a, b) Q60 with |b| fitting u64\n"
+"static inline I128 mulq60u(I128 a, ulong b) { return shri(addi(muli_u64(a, b), halfc()), 60); }\n"
+"// q60(1, e): 2^(60+e) with RNE for e < -60 (matches host q60(1, e))\n"
+"static inline I128 q60one(int e) { int ee = 60 + e; I128 r; r.lo = 0; r.hi = 0; if (ee >= 0) { if (ee >= 64) r.hi = (long)(1ul << (ee - 64)); else r.lo = 1ul << ee; } else { r.lo = ee == -1 ? 1 : 0; } return r; }\n"
+"// sfrom(amax, cur) = amax*cur/ALVL via overflow-safe split (amax fits u64)\n"
+"static inline I128 sfromu(ulong amax, I128 cur) {\n"
+"    const ulong ALVL = (1ul << 23) - 1;\n"
+"    ulong qa = amax / ALVL; ulong ra = amax % ALVL;\n"
+"    I128 t1 = muli_u64(cur, qa);\n"
+"    I128 t2 = muli_u64(cur, ra);\n"
+"    I128 rr; I128 t3 = divmag(t2, mk64((long)ALVL), &rr);\n"
+"    return addi(t1, t3);\n"
+"}\n"
+"struct MP { uint nsb; uint rows_per_seg; uint nseg; uint fexp; ulong toff; uint segs_are_experts; uint which_half; uint seg_base; uint pad; };\n"
+"struct O { ulong lo; long hi; int emin; int pad; };\n"
+"static inline void f16me(ushort b, thread long &m, thread int &e) {\n"
+"    int e5 = (b >> 10) & 31; long fr = b & 1023;\n"
+"    if (e5 == 0) { m = fr; e = -24; } else { m = 1024 + fr; e = e5 - 25; }\n"
+"    if (b & 0x8000) m = -m;\n"
+"}\n"
+"static inline void acc128(thread ulong &lo, thread long &hi, long a, int s) {\n"
+"    ulong lp; long hp;\n"
+"    if (s == 0) { lp = (ulong)a; hp = a < 0 ? -1 : 0; }\n"
+"    else { lp = ((ulong)a) << s; hp = a >> (64 - s); }\n"
+"    ulong nlo = lo + lp; hi += hp + (nlo < lo ? 1 : 0); lo = nlo;\n"
+"}\n"
+"// ---- 1. router: one thread per expert, exact I128 accumulation ----\n"
+"kernel void k_router(device const long* RW [[buffer(0)]], device const int* X [[buffer(1)]],\n"
+"                     device I128* LG [[buffer(2)]], uint gid [[thread_position_in_grid]]) {\n"
+"    if (gid >= 256) return;\n"
+"    I128 acc; acc.lo = 0; acc.hi = 0;\n"
+"    device const long* w = RW + gid * 2048;\n"
+"    for (uint i = 0; i < 2048; i++) { acc = addi(acc, mk64(w[i] * (long)X[i])); }\n"
+"    LG[gid] = acc;\n"
+"}\n"
+"// ---- 2. softmax + deterministic top-8 + normalized weights (single thread) ----\n"
+"// REGS: [0]=xs  [1]=u  writes: SEL[0..7], WN[0..7] (i64 Q30), REGS[2]=den(unused later)\n"
+"kernel void k_topk(device const I128* LG [[buffer(0)]], device const long* EXPN [[buffer(1)]],\n"
+"                   device I128* REGS [[buffer(2)]], device uint* SEL [[buffer(3)]],\n"
+"                   device long* WN [[buffer(4)]], uint tid [[thread_position_in_threadgroup]]) {\n"
+"    threadgroup I128 tg_lg[256];\n"
+"    threadgroup long tg_es[256];\n"
+"    tg_lg[tid] = LG[tid];\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = 128; s > 0; s >>= 1) {\n"
+"        if (tid < s) { if (lti(tg_lg[tid], tg_lg[tid + s])) tg_lg[tid] = tg_lg[tid + s]; }\n"
+"        threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    }\n"
+"    I128 m = tg_lg[0];\n"
+"    I128 xs = REGS[0];\n"
+"    I128 u = mulq60u(xs, 1ul << 30);\n"
+"    I128 c2048 = muli_u64(u, 2048);\n"
+"    ulong c2 = c2048.lo;\n"
+"    {\n"
+"        I128 d = addi(m, negi(LG[tid]));\n"
+"        I128 idx = applyu(d, c2);\n"
+"        long ix = (long)idx.lo; if (idx.hi != 0) ix = 999999;\n"
+"        tg_es[tid] = (ix < 16384) ? EXPN[ix] : 0;\n"
+"    }\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    if (tid != 0) return;\n"
+"    REGS[1] = u;\n"
+"    bool used[256]; for (uint e = 0; e < 256; e++) used[e] = false;\n"
+"    long dsel = 0;\n"
+"    for (uint r = 0; r < 8; r++) {\n"
+"        uint best = 256; long bv = -1;\n"
+"        for (uint e = 0; e < 256; e++) if (!used[e] && (best == 256 || tg_es[e] > bv)) { best = e; bv = tg_es[e]; }\n"
+"        used[best] = true; SEL[r] = best; dsel += tg_es[best];\n"
+"    }\n"
+"    if (dsel == 0) dsel = 1;\n"
+"    // single-step normalization — must match CPU: wn = fdiv(es*2^30 + dsel/2, dsel)\n"
+"    for (uint r = 0; r < 8; r++) {\n"
+"        I128 nmr = addi(shli(mk64(tg_es[SEL[r]]), 30), mk64(dsel >> 1));\n"
+"        WN[r] = (long)fdivi(nmr, mk64(dsel)).lo;\n"
+"    }\n"
+"}\n"
+"// ---- 3. expert gemm (Q4_K / Q6_K), row offset from SEL ----\n"
+"kernel void k_gemm4_exp(device const uchar* W [[buffer(0)]], device const int* X [[buffer(1)]],\n"
+"                        device O* out [[buffer(2)]], constant MP& p [[buffer(3)]],\n"
+"                        device const uint* SEL [[buffer(4)]], uint gid [[thread_position_in_grid]]) {\n"
+"    uint total = p.nseg * p.rows_per_seg; if (gid >= total) return;\n"
+"    uint seg = gid / p.rows_per_seg, row = gid % p.rows_per_seg;\n"
+"    uint erow = (p.segs_are_experts != 0) ? (SEL[seg] * p.rows_per_seg + row) : row;\n"
+"    device const uchar* rp = W + p.toff + (ulong)erow * p.nsb * 144;\n"
+"    long A[16]; int EA[16]; long B[16]; int EB[16]; int emin = 2147483647;\n"
+"    for (uint b = 0; b < p.nsb; b++) {\n"
+"        device const uchar* blk = rp + b * 144;\n"
+"        long dm; int de; f16me((ushort)blk[0] | ((ushort)blk[1] << 8), dm, de);\n"
+"        long mm; int me; f16me((ushort)blk[2] | ((ushort)blk[3] << 8), mm, me);\n"
+"        long asum = 0, bsum = 0;\n"
+"        for (uint j = 0; j < 8; j++) {\n"
+"            long sc, mn;\n"
+"            if (j < 4) { sc = blk[4 + j] & 63; mn = blk[4 + j + 4] & 63; }\n"
+"            else { sc = (blk[4 + j + 4] & 0xF) | ((blk[4 + j - 4] >> 6) << 4);\n"
+"                   mn = (blk[4 + j + 4] >> 4) | ((blk[4 + j] >> 6) << 4); }\n"
+"            uint c = j / 2; uint hlf = j % 2;\n"
+"            device const uchar* qb = blk + 16 + 32 * c;\n"
+"            device const int* xv = X + b * 256 + 64 * c + 32 * hlf;\n"
+"            long dot = 0, sm = 0;\n"
+"            if (hlf == 0) { for (uint l = 0; l < 32; l++) { int q = qb[l] & 0xF; int x = xv[l]; dot += q * x; sm += x; } }\n"
+"            else { for (uint l = 0; l < 32; l++) { int q = qb[l] >> 4; int x = xv[l]; dot += q * x; sm += x; } }\n"
+"            asum += sc * dot; bsum += mn * sm;\n"
+"        }\n"
+"        A[b] = dm * asum; EA[b] = de; B[b] = mm * bsum; EB[b] = me;\n"
+"        if (A[b] != 0 && de < emin) emin = de;\n"
+"        if (B[b] != 0 && me < emin) emin = me;\n"
+"    }\n"
+"    if (emin == 2147483647) emin = 0;\n"
+"    ulong lo = 0; long hi = 0;\n"
+"    for (uint b = 0; b < p.nsb; b++) { acc128(lo, hi, A[b], EA[b] - emin); acc128(lo, hi, -B[b], EB[b] - emin); }\n"
+"    out[gid].lo = lo; out[gid].hi = hi; out[gid].emin = emin; out[gid].pad = 0;\n"
+"}\n"
+"kernel void k_gemm6_exp(device const uchar* W [[buffer(0)]], device const int* X [[buffer(1)]],\n"
+"                        device O* out [[buffer(2)]], constant MP& p [[buffer(3)]],\n"
+"                        device const uint* SEL [[buffer(4)]], uint gid [[thread_position_in_grid]]) {\n"
+"    uint total = p.nseg * p.rows_per_seg; if (gid >= total) return;\n"
+"    uint seg = gid / p.rows_per_seg, row = gid % p.rows_per_seg;\n"
+"    uint erow = (p.segs_are_experts != 0) ? (SEL[seg] * p.rows_per_seg + row) : row;\n"
+"    device const int* XSEG = X + ((p.segs_are_experts != 0) ? seg : 0) * (p.nsb * 256) * (p.which_half != 0 ? 1 : 0);\n"
+"    device const uchar* rp = W + p.toff + (ulong)erow * p.nsb * 210;\n"
+"    long A[16]; int EA[16]; int emin = 2147483647;\n"
+"    for (uint b = 0; b < p.nsb; b++) {\n"
+"        device const uchar* blk = rp + b * 210;\n"
+"        device const uchar* ql = blk; device const uchar* qh = blk + 128;\n"
+"        long dm; int de; f16me((ushort)blk[208] | ((ushort)blk[209] << 8), dm, de);\n"
+"        long asum = 0;\n"
+"        for (uint hlf = 0; hlf < 2; hlf++) {\n"
+"            device const uchar* qlh = ql + 64 * hlf; device const uchar* qhh = qh + 32 * hlf;\n"
+"            uint base = b * 256 + 128 * hlf; uint sco = 8 * hlf;\n"
+"            for (uint l = 0; l < 32; l++) {\n"
+"                uint is = l / 16;\n"
+"                int q1 = (int)((qlh[l] & 0xF) | (((qhh[l] >> 0) & 3) << 4)) - 32;\n"
+"                int q2 = (int)((qlh[l + 32] & 0xF) | (((qhh[l] >> 2) & 3) << 4)) - 32;\n"
+"                int q3 = (int)((qlh[l] >> 4) | (((qhh[l] >> 4) & 3) << 4)) - 32;\n"
+"                int q4 = (int)((qlh[l + 32] >> 4) | (((qhh[l] >> 6) & 3) << 4)) - 32;\n"
+"                long d1 = (long)q1 * XSEG[base + l]; long d2 = (long)q2 * XSEG[base + l + 32];\n"
+"                long d3 = (long)q3 * XSEG[base + l + 64]; long d4 = (long)q4 * XSEG[base + l + 96];\n"
+"                asum += (long)(char)blk[192 + sco + is] * d1; asum += (long)(char)blk[192 + sco + is + 2] * d2;\n"
+"                asum += (long)(char)blk[192 + sco + is + 4] * d3; asum += (long)(char)blk[192 + sco + is + 6] * d4;\n"
+"            }\n"
+"        }\n"
+"        A[b] = dm * asum; EA[b] = de; if (A[b] != 0 && de < emin) emin = de;\n"
+"    }\n"
+"    if (emin == 2147483647) emin = 0;\n"
+"    ulong lo = 0; long hi = 0;\n"
+"    for (uint b = 0; b < p.nsb; b++) acc128(lo, hi, A[b], EA[b] - emin);\n"
+"    out[gid].lo = lo; out[gid].hi = hi; out[gid].emin = emin; out[gid].pad = 0;\n"
+"}\n"
+"// ---- fused proj_finish: colsq -> cmax -> rescale -> amax -> aq -> scale, one dispatch ----\n"
+"struct FF { uint rows; uint xs_slot; uint xs_per_seg; uint sout_base; };\n"
+"kernel void k_finish(device const O* ACC [[buffer(0)]], device I128* COLSQ [[buffer(1)]],\n"
+"                     device long* RESC [[buffer(2)]], device int* Q [[buffer(3)]],\n"
+"                     device I128* REGS [[buffer(4)]], constant FF& p [[buffer(5)]],\n"
+"                     uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]],\n"
+"                     uint tpg [[threads_per_threadgroup]]) {\n"
+"    threadgroup I128 sh[256];\n"
+"    threadgroup I128 tg_cmax;\n"
+"    threadgroup ulong shu[256];\n"
+"    threadgroup ulong tg_amax;\n"
+"    I128 xs = REGS[p.xs_per_seg != 0 ? (p.xs_slot + tg) : p.xs_slot];\n"
+"    I128 mymax; mymax.lo = 0; mymax.hi = 0;\n"
+"    for (uint r = tid; r < p.rows; r += tpg) {\n"
+"        uint idx = tg * p.rows + r;\n"
+"        int ee = 60 + ACC[idx].emin;\n"
+"        I128 cs;\n"
+"        if (ee >= 0) cs = shri(addi(shli(xs, (uint)ee), halfc()), 60);\n"
+"        else { cs.lo = 0; cs.hi = 0; }\n"
+"        COLSQ[idx] = cs;\n"
+"        if (lti(mymax, cs)) mymax = cs;\n"
+"    }\n"
+"    sh[tid] = mymax;\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = tpg / 2; s > 0; s >>= 1) { if (tid < s) { if (lti(sh[tid], sh[tid + s])) sh[tid] = sh[tid + s]; } threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    if (tid == 0) { I128 c = sh[0]; if (c.lo == 0 && c.hi == 0) c = mk64(1); tg_cmax = c; }\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    I128 cmax = tg_cmax;\n"
+"    ulong mymaxu = 0;\n"
+"    for (uint r = tid; r < p.rows; r += tpg) {\n"
+"        uint idx = tg * p.rows + r;\n"
+"        I128 acc; acc.lo = ACC[idx].lo; acc.hi = ACC[idx].hi;\n"
+"        I128 ratio = divmag(shli(COLSQ[idx], 60), cmax, 0);\n"
+"        I128 v = applyu(acc, ratio.lo);\n"
+"        long vv = (long)v.lo;\n"
+"        RESC[idx] = vv;\n"
+"        ulong a = (ulong)(vv < 0 ? -vv : vv); if (a > mymaxu) mymaxu = a;\n"
+"    }\n"
+"    shu[tid] = mymaxu;\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = tpg / 2; s > 0; s >>= 1) { if (tid < s) shu[tid] = max(shu[tid], shu[tid + s]); threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    if (tid == 0) tg_amax = max(shu[0], 1ul);\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    long amax = (long)tg_amax;\n"
+"    const long ALVL = (1l << 23) - 1;\n"
+"    for (uint r = tid; r < p.rows; r += tpg) {\n"
+"        uint idx = tg * p.rows + r;\n"
+"        long x = RESC[idx];\n"
+"        long sg = x > 0 ? amax : (x < 0 ? -amax : 0);\n"
+"        I128 nmr = addi(muli_u64(mk64(x), (ulong)(2 * ALVL)), mk64(sg));\n"
+"        Q[idx] = (int)fdivi(nmr, mk64(2 * amax)).lo;\n"
+"    }\n"
+"    if (tid == 0) REGS[p.sout_base + tg] = sfromu((ulong)amax, cmax);\n"
+"}\n"
+"// ---- fused raw finish: amax -> aq -> scale over raw i64 vectors (hm / tot) ----\n"
+"struct FR { uint rows; uint cur_base; uint sout_base; uint pad; };\n"
+"kernel void k_finraw(device const long* V [[buffer(0)]], device int* Q [[buffer(1)]],\n"
+"                     device I128* REGS [[buffer(2)]], constant FR& p [[buffer(3)]],\n"
+"                     uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]],\n"
+"                     uint tpg [[threads_per_threadgroup]]) {\n"
+"    threadgroup ulong shu[256];\n"
+"    threadgroup ulong tg_amax;\n"
+"    ulong mymax = 0;\n"
+"    for (uint r = tid; r < p.rows; r += tpg) { long v = V[tg * p.rows + r]; ulong a = (ulong)(v < 0 ? -v : v); if (a > mymax) mymax = a; }\n"
+"    shu[tid] = mymax;\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = tpg / 2; s > 0; s >>= 1) { if (tid < s) shu[tid] = max(shu[tid], shu[tid + s]); threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    if (tid == 0) tg_amax = max(shu[0], 1ul);\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    long amax = (long)tg_amax;\n"
+"    const long ALVL = (1l << 23) - 1;\n"
+"    for (uint r = tid; r < p.rows; r += tpg) {\n"
+"        uint idx = tg * p.rows + r;\n"
+"        long x = V[idx];\n"
+"        long sg = x > 0 ? amax : (x < 0 ? -amax : 0);\n"
+"        I128 nmr = addi(muli_u64(mk64(x), (ulong)(2 * ALVL)), mk64(sg));\n"
+"        Q[idx] = (int)fdivi(nmr, mk64(2 * amax)).lo;\n"
+"    }\n"
+"    if (tid == 0) REGS[p.sout_base + tg] = sfromu((ulong)amax, REGS[p.cur_base + tg]);\n"
+"}\n"
+"// ---- 4. per-segment colsq + cmax reduction (one threadgroup per segment) ----\n"
+"// REGS layout: xs at slot xs_slot; writes cmax at cmax_base+seg\n"
+"struct FP { uint rows; uint xs_slot; uint cmax_base; uint pad; };\n"
+"kernel void k_colsq(device const O* ACC [[buffer(0)]], device I128* COLSQ [[buffer(1)]],\n"
+"                    device I128* REGS [[buffer(2)]], constant FP& p [[buffer(3)]],\n"
+"                    uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]],\n"
+"                    uint tpg [[threads_per_threadgroup]]) {\n"
+"    threadgroup I128 sh[256];\n"
+"    I128 xs = REGS[p.xs_slot];\n"
+"    I128 mymax; mymax.lo = 0; mymax.hi = 0;\n"
+"    for (uint r = tid; r < p.rows; r += tpg) {\n"
+"        uint idx = tg * p.rows + r;\n"
+"        int e = ACC[idx].emin;\n"
+"        // colsq = mul(xs, 2^(60+e)) = (xs << (60+e) + HALF) >> 60 — exact CPU equivalence (incl. wrap)\n"
+"        int ee = 60 + e;\n"
+"        I128 cs;\n"
+"        if (ee >= 0) cs = shri(addi(shli(xs, (uint)ee), halfc()), 60);\n"
+"        else { cs.lo = 0; cs.hi = 0; }\n"
+"        COLSQ[idx] = cs;\n"
+"        if (lti(mymax, cs)) mymax = cs;\n"
+"    }\n"
+"    sh[tid] = mymax;\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = tpg / 2; s > 0; s >>= 1) {\n"
+"        if (tid < s) { if (lti(sh[tid], sh[tid + s])) sh[tid] = sh[tid + s]; }\n"
+"        threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    }\n"
+"    if (tid == 0) { I128 c = sh[0]; if (c.lo == 0 && c.hi == 0) c = mk64(1); REGS[p.cmax_base + tg] = c; }\n"
+"}\n"
+"// ---- 5. rescale + per-segment amax(i64) reduction ----\n"
+"struct RP { uint rows; uint cmax_base; uint amax_base; uint pad; };\n"
+"kernel void k_rescale(device const O* ACC [[buffer(0)]], device const I128* COLSQ [[buffer(1)]],\n"
+"                      device long* RESC [[buffer(2)]], device I128* REGS [[buffer(3)]],\n"
+"                      constant RP& p [[buffer(4)]],\n"
+"                      uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]],\n"
+"                      uint tpg [[threads_per_threadgroup]]) {\n"
+"    threadgroup ulong sh[256];\n"
+"    I128 cmax = REGS[p.cmax_base + tg];\n"
+"    ulong mymax = 0;\n"
+"    for (uint r = tid; r < p.rows; r += tpg) {\n"
+"        uint idx = tg * p.rows + r;\n"
+"        I128 acc; acc.lo = ACC[idx].lo; acc.hi = ACC[idx].hi;\n"
+"        I128 ratio = divmag(shli(COLSQ[idx], 60), cmax, 0);\n"
+"        I128 v = applyu(acc, ratio.lo);\n"
+"        long vv = (long)v.lo;\n"
+"        RESC[idx] = vv;\n"
+"        ulong a = (ulong)(vv < 0 ? -vv : vv); if (a > mymax) mymax = a;\n"
+"    }\n"
+"    sh[tid] = mymax;\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = tpg / 2; s > 0; s >>= 1) { if (tid < s) sh[tid] = max(sh[tid], sh[tid + s]); threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    if (tid == 0) { REGS[p.amax_base + tg] = mk64((long)max(sh[0], 1ul)); }\n"
+"}\n"
+"// ---- 6. quantize A24 + segment scale s = sfrom(amax, cur) ----\n"
+"struct AP { uint rows; uint amax_base; uint cur_base; uint sout_base; };\n"
+"kernel void k_aqseg(device const long* RESC [[buffer(0)]], device int* Q [[buffer(1)]],\n"
+"                    device I128* REGS [[buffer(2)]], constant AP& p [[buffer(3)]],\n"
+"                    uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]],\n"
+"                    uint tpg [[threads_per_threadgroup]]) {\n"
+"    const long ALVL = (1l << 23) - 1;\n"
+"    long amax = (long)REGS[p.amax_base + tg].lo;\n"
+"    for (uint r = tid; r < p.rows; r += tpg) {\n"
+"        uint idx = tg * p.rows + r;\n"
+"        long x = RESC[idx];\n"
+"        long sg = x > 0 ? amax : (x < 0 ? -amax : 0);\n"
+"        I128 nmr = addi(muli_u64(mk64(x), (ulong)(2 * ALVL)), mk64(sg));\n"
+"        Q[idx] = (int)fdivi(nmr, mk64(2 * amax)).lo;\n"
+"    }\n"
+"    if (tid == 0) REGS[p.sout_base + tg] = sfromu((ulong)amax, REGS[p.cur_base + tg]);\n"
+"}\n"
+"// ---- 7. silu(gate)*up -> hm (i64) per expert pair; cur_hm = mul(us, 2^44) by thread0 ----\n"
+"struct SP { uint rows; uint gs_base; uint us_base; uint curhm_base; };\n"
+"kernel void k_siluup(device const int* QG [[buffer(0)]], device const int* QU [[buffer(1)]],\n"
+"                     device long* HM [[buffer(2)]], device const long* SIG [[buffer(3)]],\n"
+"                     device I128* REGS [[buffer(4)]], constant SP& p [[buffer(5)]],\n"
+"                     uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]],\n"
+"                     uint tpg [[threads_per_threadgroup]]) {\n"
+"    I128 gs = REGS[p.gs_base + tg];\n"
+"    for (uint r = tid; r < p.rows; r += tpg) {\n"
+"        uint idx = tg * p.rows + r;\n"
+"        I128 g16i = shri(addi(muli_i64(gs, (long)QG[idx]), mk64(1l << 43)), 44);\n"
+"        long g16 = (long)g16i.lo;\n"
+"        long i7 = ((g16 + (1l << 6)) >> 7) + 8192;\n"
+"        i7 = clamp(i7, 0l, 16383l);\n"
+"        long silu = (g16 * SIG[i7]) >> 16;\n"
+"        HM[idx] = silu * (long)QU[idx];\n"
+"    }\n"
+"    if (tid == 0) REGS[p.curhm_base + tg] = mulq60u(REGS[p.us_base + tg], 1ul << 44);\n"
+"}\n"
+"// ---- 8. amax over raw i64 vector (for hm and tot) ----\n"
+"kernel void k_amaxraw(device const long* V [[buffer(0)]], device I128* REGS [[buffer(1)]],\n"
+"                      constant AP& p [[buffer(2)]],\n"
+"                      uint tid [[thread_position_in_threadgroup]], uint tg [[threadgroup_position_in_grid]],\n"
+"                      uint tpg [[threads_per_threadgroup]]) {\n"
+"    threadgroup ulong sh[256];\n"
+"    ulong mymax = 0;\n"
+"    for (uint r = tid; r < p.rows; r += tpg) { long v = V[tg * p.rows + r]; ulong a = (ulong)(v < 0 ? -v : v); if (a > mymax) mymax = a; }\n"
+"    sh[tid] = mymax;\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = tpg / 2; s > 0; s >>= 1) { if (tid < s) sh[tid] = max(sh[tid], sh[tid + s]); threadgroup_barrier(mem_flags::mem_threadgroup); }\n"
+"    if (tid == 0) REGS[p.amax_base + tg] = mk64((long)max(sh[0], 1ul));\n"
+"}\n"
+"// ---- 9. combine scales for weighted sum (single thread) ----\n"
+"// ds at ds_base+seg (9), wn from WN; writes accs_base+seg (i128), smax2 at smax_slot, ratios rat_base+seg (u64 in lo)\n"
+"struct CP { uint ds_base; uint accs_base; uint smax_slot; uint rat_base; uint sh16_slot; uint pad0; uint pad1; uint pad2; };\n"
+"kernel void k_combine(device I128* REGS [[buffer(0)]], device const long* WN [[buffer(1)]],\n"
+"                      constant CP& p [[buffer(2)]], uint gid [[thread_position_in_grid]]) {\n"
+"    if (gid != 0) return;\n"
+"    I128 smax; smax.lo = 0; smax.hi = 0;\n"
+"    for (uint e = 0; e < 8; e++) {\n"
+"        I128 ds = REGS[p.ds_base + e];\n"
+"        I128 as = mulq60u(ds, (ulong)(WN[e]) << 30);\n"
+"        REGS[p.accs_base + e] = as;\n"
+"        if (lti(smax, as)) smax = as;\n"
+"    }\n"
+"    // shared expert: sigmoid gate applied to ds_shared: as_sh = mul(ds_sh, sg<<44)\n"
+"    I128 dssh = REGS[p.ds_base + 8];\n"
+"    long sg = (long)REGS[p.sh16_slot].lo;\n"
+"    I128 assh = mulq60u(dssh, (ulong)sg << 44);\n"
+"    REGS[p.accs_base + 8] = assh;\n"
+"    I128 smax2 = smax; if (lti(smax2, assh)) smax2 = assh;\n"
+"    if (smax2.lo == 0 && smax2.hi == 0) smax2 = mk64(1);\n"
+"    REGS[p.smax_slot] = smax2;\n"
+"    for (uint e = 0; e < 9; e++) {\n"
+"        I128 r = divmag(shli(REGS[p.accs_base + e], 60), smax2, 0);\n"
+"        REGS[p.rat_base + e] = r;\n"
+"    }\n"
+"    // note: routed experts rescale to smax then combined with shared at smax2 on CPU; here we\n"
+"    // fold both steps: CPU does apply(q, (as<<60)/smax) summed, then apply(tot, r1)+apply(dq_sh, r2).\n"
+"    // To stay bit-exact we replicate the exact two-step sequence in k_weighted.\n"
+"    I128 smax1 = smax; if (smax1.lo == 0 && smax1.hi == 0) smax1 = mk64(1);\n"
+"    REGS[p.smax_slot + 1] = smax1;\n"
+"    for (uint e = 0; e < 8; e++) REGS[p.rat_base + 16 + e] = divmag(shli(REGS[p.accs_base + e], 60), smax1, 0);\n"
+"    REGS[p.rat_base + 24] = divmag(shli(smax1, 60), smax2, 0);           // r1\n"
+"    REGS[p.rat_base + 25] = divmag(shli(REGS[p.accs_base + 8], 60), smax2, 0); // r2\n"
+"}\n"
+"// ---- 10. weighted sum (exact CPU sequence): tot_i = apply(sum_e apply(dq_e, rat1_e), r1) + apply(dq_sh, r2) ----\n"
+"struct WP { uint n; uint rat_base; uint pad0; uint pad1; };\n"
+"kernel void k_weighted(device const int* QDN [[buffer(0)]], device long* TOT [[buffer(1)]],\n"
+"                       device const I128* REGS [[buffer(2)]], constant WP& p [[buffer(3)]],\n"
+"                       uint gid [[thread_position_in_grid]]) {\n"
+"    if (gid >= p.n) return;\n"
+"    I128 t; t.lo = 0; t.hi = 0;\n"
+"    for (uint e = 0; e < 8; e++) {\n"
+"        long dq = (long)QDN[e * p.n + gid];\n"
+"        t = addi(t, applyu(mk64(dq), REGS[p.rat_base + 16 + e].lo));\n"
+"    }\n"
+"    I128 v = applyu(t, REGS[p.rat_base + 24].lo);\n"
+"    long dqs = (long)QDN[8 * p.n + gid];\n"
+"    v = addi(v, applyu(mk64(dqs), REGS[p.rat_base + 25].lo));\n"
+"    TOT[gid] = (long)v.lo;\n"
+"}\n"
+"// ---- 11. shared-expert gate sigmoid: sh16 = sig[to_fix(shl, mul(xs,2^30), 16)] (single thread) ----\n"
+"struct GP { uint sh16_slot; uint pad0; uint pad1; uint pad2; };\n"
+"kernel void k_shgate(device const long* SW [[buffer(0)]], device const int* X [[buffer(1)]],\n"
+"                     device const long* SIG [[buffer(2)]], device I128* REGS [[buffer(3)]],\n"
+"                     constant GP& p [[buffer(4)]], uint tid [[thread_position_in_threadgroup]]) {\n"
+"    threadgroup I128 tg_acc[256];\n"
+"    I128 acc; acc.lo = 0; acc.hi = 0;\n"
+"    for (uint i = tid; i < 2048; i += 256) acc = addi(acc, mk64(SW[i] * (long)X[i]));\n"
+"    tg_acc[tid] = acc;\n"
+"    threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    for (uint s = 128; s > 0; s >>= 1) {\n"
+"        if (tid < s) tg_acc[tid] = addi(tg_acc[tid], tg_acc[tid + s]);\n"
+"        threadgroup_barrier(mem_flags::mem_threadgroup);\n"
+"    }\n"
+"    if (tid != 0) return;\n"
+"    acc = tg_acc[0];\n"
+"    I128 u = REGS[1];\n"
+"    bool n = isneg(acc); I128 am = mag(acc);\n"
+"    I128 t = mulmag_u64(am, u.lo);\n"
+"    if (n) t = negi(t);\n"
+"    I128 s16 = shri(addi(t, mk64(1l << 43)), 44);\n"
+"    long v16 = (long)s16.lo;\n"
+"    long i7 = ((v16 + (1l << 6)) >> 7) + 8192; i7 = clamp(i7, 0l, 16383l);\n"
+"    I128 res; res.lo = (ulong)SIG[i7]; res.hi = 0;\n"
+"    REGS[p.sh16_slot] = res;\n"
+"}\n";
+
+typedef struct {
+    const void *gate_ptr; unsigned long long gate_len; unsigned long long gate_off_unused;
+    const void *up_ptr; unsigned long long up_len;
+    const void *down_ptr; unsigned long long down_len;
+    const void *gsh_ptr; unsigned long long gsh_len;
+    const void *ush_ptr; unsigned long long ush_len;
+    const void *dsh_ptr; unsigned long long dsh_len;
+    unsigned layer;
+} MoeTensors;
+
+int qi35_moe_init(const long *sig, const long *expn) {
+    id<MTLDevice> dev = qi35_dev();
+    NSError *err = nil;
+    id<MTLLibrary> lib = [dev newLibraryWithSource:kMoeSrc options:nil error:&err];
+    if (!lib) { fprintf(stderr, "qi35moe: %s\n", err.description.UTF8String); return -1; }
+    #define PIPE(v, n) v = [dev newComputePipelineStateWithFunction:[lib newFunctionWithName:@n] error:&err]; if (!v) { fprintf(stderr, "qi35moe pipe %s\n", n); return -2; }
+    PIPE(pRouter, "k_router"); PIPE(pTopk, "k_topk"); PIPE(pGemm4Exp, "k_gemm4_exp"); PIPE(pGemm6Exp, "k_gemm6_exp");
+    PIPE(pColsq, "k_colsq"); PIPE(pRescale, "k_rescale"); PIPE(pAqSeg, "k_aqseg"); PIPE(pSiluUp, "k_siluup");
+    { extern id<MTLComputePipelineState> qi35_pFinish, qi35_pFinraw;
+      qi35_pFinish = [dev newComputePipelineStateWithFunction:[lib newFunctionWithName:@"k_finish"] error:&err];
+      qi35_pFinraw = [dev newComputePipelineStateWithFunction:[lib newFunctionWithName:@"k_finraw"] error:&err];
+      if (!qi35_pFinish || !qi35_pFinraw) { fprintf(stderr, "qi35moe fused pipes failed\n"); return -5; } }
+    PIPE(pAmaxRaw, "k_amaxraw"); PIPE(pCombine, "k_combine"); PIPE(pWeighted, "k_weighted");
+    { extern id<MTLComputePipelineState> qi35_pGemm4, qi35_pGemm6;
+      qi35_pGemm4 = pGemm4Exp; qi35_pGemm6 = pGemm6Exp; }
+    static id<MTLComputePipelineState> pShGate;
+    PIPE(pShGate, "k_shgate");
+    // stash in bRouters[63] trick? keep a static
+    extern id<MTLComputePipelineState> qi35_shgate_pipe;
+    qi35_shgate_pipe = pShGate;
+    bSig = [dev newBufferWithBytes:sig length:16384 * 8 options:MTLResourceStorageModeShared];
+    bExpn = [dev newBufferWithBytes:expn length:16384 * 8 options:MTLResourceStorageModeShared];
+    bXq = [dev newBufferWithLength:2048 * 4 options:MTLResourceStorageModeShared];
+    bXregs = [dev newBufferWithLength:256 * 16 options:MTLResourceStorageModeShared];
+    bSel = [dev newBufferWithLength:8 * 4 options:MTLResourceStorageModeShared];
+    bLogits = [dev newBufferWithLength:256 * 16 options:MTLResourceStorageModeShared];
+    static id<MTLBuffer> bWn_;
+    extern id<MTLBuffer> qi35_bWn;
+    bWn_ = [dev newBufferWithLength:8 * 8 options:MTLResourceStorageModeShared];
+    qi35_bWn = bWn_;
+    bAccGU = [dev newBufferWithLength:18 * 512 * 24 options:MTLResourceStorageModeShared];
+    bColsqGU = [dev newBufferWithLength:18 * 512 * 16 options:MTLResourceStorageModeShared];
+    bRescGU = [dev newBufferWithLength:18 * 512 * 8 options:MTLResourceStorageModeShared];
+    bQGU = [dev newBufferWithLength:18 * 512 * 4 options:MTLResourceStorageModeShared];
+    bHm = [dev newBufferWithLength:9 * 512 * 8 options:MTLResourceStorageModeShared];
+    bQHm = [dev newBufferWithLength:9 * 512 * 4 options:MTLResourceStorageModeShared];
+    bAccDn = [dev newBufferWithLength:9 * 2048 * 24 options:MTLResourceStorageModeShared];
+    bColsqDn = [dev newBufferWithLength:9 * 2048 * 16 options:MTLResourceStorageModeShared];
+    bRescDn = [dev newBufferWithLength:9 * 2048 * 8 options:MTLResourceStorageModeShared];
+    bQDn = [dev newBufferWithLength:9 * 2048 * 4 options:MTLResourceStorageModeShared];
+    bTot = [dev newBufferWithLength:2048 * 8 options:MTLResourceStorageModeShared];
+    bMq = [dev newBufferWithLength:2048 * 4 options:MTLResourceStorageModeShared];
+    return 0;
+}
+id<MTLComputePipelineState> qi35_shgate_pipe;
+id<MTLComputePipelineState> qi35_pFinish, qi35_pFinraw;
+id<MTLComputePipelineState> qi35_pGemm4, qi35_pGemm6;
+id<MTLBuffer> qi35_bWn;
+
+void qi35_moe_upload_router(unsigned layer, const long *router, const long *shw) {
+    id<MTLDevice> dev = qi35_dev();
+    id<MTLBuffer> b = [dev newBufferWithLength:(256 * 2048 + 2048) * 8 options:MTLResourceStorageModeShared];
+    memcpy(b.contents, router, 256 * 2048 * 8);
+    memcpy((char *)b.contents + 256 * 2048 * 8, shw, 2048 * 8);
+    bRouters[layer] = b;
+}
+
+// REG slots: 0=xs 1=u 8..25 s_gateup(18) 26..34 cur==cmax? layout below
+// cmax_gu: 40..57 (18)  amax_gu: 60..77  s_gu: 8..25
+// curhm: 80..88  amax_hm: 90..98  s_hm: 100..108
+// cmax_dn: 110..118 amax_dn: 120..128 s_dn(ds): 130..138
+// accs: 140..148  smax2:150 smax1:151  rat:160..185  sh16: 190  amax_tot: 200  s_out: 201  cur_out(=smax2 copy):202
+static int moe_stage(void) {
+    static int st = -1;
+    if (st < 0) { const char *e = getenv("QI35_MOE_STAGE"); st = e ? atoi(e) : 0; }
+    return st;
+}
+#define STAGE_CUT(n) if (moe_stage() == (n)) { goto finish; }
+int qi35_moe_run(const MoeTensors *t, const int *xq, const unsigned char *xs16,
+                 unsigned *sel_out, int *mq_out, unsigned char *ms16_out) {
+    id<MTLDevice> dev = qi35_dev();
+    memcpy(bXq.contents, xq, 2048 * 4);
+    memcpy((char *)bXregs.contents, xs16, 16); // slot 0 = xs
+    id<MTLCommandBuffer> cb = [qi35_queue() commandBuffer];
+    id<MTLComputeCommandEncoder> e = [cb computeCommandEncoderWithDispatchType:MTLDispatchTypeConcurrent];
+    #define BARRIER [e memoryBarrierWithScope:MTLBarrierScopeBuffers]
+    unsigned long long d;
+    id<MTLBuffer> rb = bRouters[t->layer];
+    struct MPh { unsigned nsb, rows, nseg, fexp; unsigned long long toff; unsigned segsexp, which, segbase, pad; } mp;
+    id<MTLBuffer> wb;
+
+    // ---- phase 1 (concurrent): router — needs only X ----
+    [e setComputePipelineState:pRouter];
+    [e setBuffer:rb offset:0 atIndex:0];
+    [e setBuffer:bXq offset:0 atIndex:1];
+    [e setBuffer:bLogits offset:0 atIndex:2];
+    [e dispatchThreads:MTLSizeMake(256, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+    // shared-expert gemms don't depend on SEL — run them here too
+    wb = qi35_buffer_for(t->gsh_ptr, t->gsh_len, &d);
+    mp = (struct MPh){ 8, 512, 1, 512, d, 0, 0, 0, 0 };
+    [e setComputePipelineState:pGemm4Exp];
+    [e setBuffer:wb offset:0 atIndex:0];
+    [e setBuffer:bXq offset:0 atIndex:1];
+    [e setBuffer:bAccGU offset:16 * 512 * 24 atIndex:2];
+    [e setBytes:&mp length:sizeof(mp) atIndex:3];
+    [e setBuffer:bSel offset:0 atIndex:4];
+    [e dispatchThreads:MTLSizeMake(512, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+    wb = qi35_buffer_for(t->ush_ptr, t->ush_len, &d);
+    mp.toff = d;
+    [e setBuffer:wb offset:0 atIndex:0];
+    [e setBuffer:bAccGU offset:17 * 512 * 24 atIndex:2];
+    [e setBytes:&mp length:sizeof(mp) atIndex:3];
+    [e dispatchThreads:MTLSizeMake(512, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+    BARRIER;
+
+    // ---- phase 2: topk (SEL/WN) ----
+    [e setComputePipelineState:pTopk];
+    [e setBuffer:bLogits offset:0 atIndex:0];
+    [e setBuffer:bExpn offset:0 atIndex:1];
+    [e setBuffer:bXregs offset:0 atIndex:2];
+    [e setBuffer:bSel offset:0 atIndex:3];
+    [e setBuffer:qi35_bWn offset:0 atIndex:4];
+    [e dispatchThreadgroups:MTLSizeMake(1, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    BARRIER;
+
+    // ---- phase 3 (concurrent): expert gate/up gemms + shgate sigmoid ----
+    wb = qi35_buffer_for(t->gate_ptr, t->gate_len, &d);
+    mp = (struct MPh){ 8, 512, 8, 512, d, 1, 0, 0, 0 };
+    [e setComputePipelineState:pGemm4Exp];
+    [e setBuffer:wb offset:0 atIndex:0];
+    [e setBuffer:bXq offset:0 atIndex:1];
+    [e setBuffer:bAccGU offset:0 atIndex:2];
+    [e setBytes:&mp length:sizeof(mp) atIndex:3];
+    [e setBuffer:bSel offset:0 atIndex:4];
+    [e dispatchThreads:MTLSizeMake(8 * 512, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+    wb = qi35_buffer_for(t->up_ptr, t->up_len, &d);
+    mp.toff = d;
+    [e setBuffer:wb offset:0 atIndex:0];
+    [e setBuffer:bAccGU offset:8 * 512 * 24 atIndex:2];
+    [e setBytes:&mp length:sizeof(mp) atIndex:3];
+    [e dispatchThreads:MTLSizeMake(8 * 512, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+    [e setComputePipelineState:qi35_shgate_pipe];
+    [e setBuffer:rb offset:256 * 2048 * 8 atIndex:0];
+    [e setBuffer:bXq offset:0 atIndex:1];
+    [e setBuffer:bSig offset:0 atIndex:2];
+    [e setBuffer:bXregs offset:0 atIndex:3];
+    struct { unsigned a, b_, c, d_; } gp = { 190, 0, 0, 0 };
+    [e setBytes:&gp length:sizeof(gp) atIndex:4];
+    [e dispatchThreadgroups:MTLSizeMake(1, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    if (moe_stage() == 1) goto finish;
+    BARRIER;
+
+    // ---- phase 4: fused finish for gate/up (18 segs) ----
+    {
+        struct { unsigned rows, xs_slot, xs_per_seg, sout_base; } ff = { 512, 0, 0, 8 };
+        [e setComputePipelineState:qi35_pFinish];
+        [e setBuffer:bAccGU offset:0 atIndex:0];
+        [e setBuffer:bColsqGU offset:0 atIndex:1];
+        [e setBuffer:bRescGU offset:0 atIndex:2];
+        [e setBuffer:bQGU offset:0 atIndex:3];
+        [e setBuffer:bXregs offset:0 atIndex:4];
+        [e setBytes:&ff length:sizeof(ff) atIndex:5];
+        [e dispatchThreadgroups:MTLSizeMake(18, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    }
+    BARRIER;
+
+    // ---- phase 5 (concurrent): silu*up experts + shared ----
+    {
+        struct { unsigned rows, gs_base, us_base, curhm_base; } sp = { 512, 8, 16, 80 };
+        [e setComputePipelineState:pSiluUp];
+        [e setBuffer:bQGU offset:0 atIndex:0];
+        [e setBuffer:bQGU offset:8 * 512 * 4 atIndex:1];
+        [e setBuffer:bHm offset:0 atIndex:2];
+        [e setBuffer:bSig offset:0 atIndex:3];
+        [e setBuffer:bXregs offset:0 atIndex:4];
+        [e setBytes:&sp length:sizeof(sp) atIndex:5];
+        [e dispatchThreadgroups:MTLSizeMake(8, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+        struct { unsigned rows, gs_base, us_base, curhm_base; } sp2 = { 512, 8 + 16, 8 + 17, 80 + 8 };
+        [e setBuffer:bQGU offset:16 * 512 * 4 atIndex:0];
+        [e setBuffer:bQGU offset:17 * 512 * 4 atIndex:1];
+        [e setBuffer:bHm offset:8 * 512 * 8 atIndex:2];
+        [e setBytes:&sp2 length:sizeof(sp2) atIndex:5];
+        [e dispatchThreadgroups:MTLSizeMake(1, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    }
+    if (moe_stage() == 2) goto finish;
+    BARRIER;
+
+    // ---- phase 6: fused raw finish for hm (9 segs) ----
+    {
+        struct { unsigned rows, cur_base, sout_base, pad; } fr = { 512, 80, 100, 0 };
+        [e setComputePipelineState:qi35_pFinraw];
+        [e setBuffer:bHm offset:0 atIndex:0];
+        [e setBuffer:bQHm offset:0 atIndex:1];
+        [e setBuffer:bXregs offset:0 atIndex:2];
+        [e setBytes:&fr length:sizeof(fr) atIndex:3];
+        [e dispatchThreadgroups:MTLSizeMake(9, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    }
+    BARRIER;
+
+    // ---- phase 7 (concurrent): down gemms ----
+    wb = qi35_buffer_for(t->down_ptr, t->down_len, &d);
+    {
+        struct MPh mp6 = (struct MPh){ 2, 2048, 8, 512, d, 1, 1, 0, 0 };
+        [e setComputePipelineState:pGemm6Exp];
+        [e setBuffer:wb offset:0 atIndex:0];
+        [e setBuffer:bQHm offset:0 atIndex:1];
+        [e setBuffer:bAccDn offset:0 atIndex:2];
+        [e setBytes:&mp6 length:sizeof(mp6) atIndex:3];
+        [e setBuffer:bSel offset:0 atIndex:4];
+        [e dispatchThreads:MTLSizeMake(8 * 2048, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+    }
+    wb = qi35_buffer_for(t->dsh_ptr, t->dsh_len, &d);
+    {
+        struct MPh mp6s = (struct MPh){ 2, 2048, 1, 512, d, 0, 0, 0, 0 };
+        [e setBuffer:wb offset:0 atIndex:0];
+        [e setBuffer:bQHm offset:8 * 512 * 4 atIndex:1];
+        [e setBuffer:bAccDn offset:8 * 2048 * 24 atIndex:2];
+        [e setBytes:&mp6s length:sizeof(mp6s) atIndex:3];
+        [e dispatchThreads:MTLSizeMake(2048, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+    }
+    if (moe_stage() == 3) goto finish;
+    BARRIER;
+
+    // ---- phase 8: fused finish for down (9 segs, per-seg xs = s_hm) ----
+    {
+        struct { unsigned rows, xs_slot, xs_per_seg, sout_base; } ffd = { 2048, 100, 1, 130 };
+        [e setComputePipelineState:qi35_pFinish];
+        [e setBuffer:bAccDn offset:0 atIndex:0];
+        [e setBuffer:bColsqDn offset:0 atIndex:1];
+        [e setBuffer:bRescDn offset:0 atIndex:2];
+        [e setBuffer:bQDn offset:0 atIndex:3];
+        [e setBuffer:bXregs offset:0 atIndex:4];
+        [e setBytes:&ffd length:sizeof(ffd) atIndex:5];
+        [e dispatchThreadgroups:MTLSizeMake(9, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    }
+    if (moe_stage() == 4) goto finish;
+    BARRIER;
+
+    // ---- phase 9: combine -> weighted -> final finish ----
+    {
+        struct { unsigned ds_base, accs_base, smax_slot, rat_base, sh16_slot, p0, p1, p2; } cp = { 130, 140, 150, 160, 190, 0, 0, 0 };
+        [e setComputePipelineState:pCombine];
+        [e setBuffer:bXregs offset:0 atIndex:0];
+        [e setBuffer:qi35_bWn offset:0 atIndex:1];
+        [e setBytes:&cp length:sizeof(cp) atIndex:2];
+        [e dispatchThreads:MTLSizeMake(1, 1, 1) threadsPerThreadgroup:MTLSizeMake(1, 1, 1)];
+    }
+    BARRIER;
+    {
+        struct { unsigned n, rat_base, p0, p1; } wp = { 2048, 160, 0, 0 };
+        [e setComputePipelineState:pWeighted];
+        [e setBuffer:bQDn offset:0 atIndex:0];
+        [e setBuffer:bTot offset:0 atIndex:1];
+        [e setBuffer:bXregs offset:0 atIndex:2];
+        [e setBytes:&wp length:sizeof(wp) atIndex:3];
+        [e dispatchThreads:MTLSizeMake(2048, 1, 1) threadsPerThreadgroup:MTLSizeMake(64, 1, 1)];
+    }
+    BARRIER;
+    {
+        struct { unsigned rows, cur_base, sout_base, pad; } frt = { 2048, 150, 201, 0 };
+        [e setComputePipelineState:qi35_pFinraw];
+        [e setBuffer:bTot offset:0 atIndex:0];
+        [e setBuffer:bMq offset:0 atIndex:1];
+        [e setBuffer:bXregs offset:0 atIndex:2];
+        [e setBytes:&frt length:sizeof(frt) atIndex:3];
+        [e dispatchThreadgroups:MTLSizeMake(1, 1, 1) threadsPerThreadgroup:MTLSizeMake(256, 1, 1)];
+    }
+    finish:
+    [e endEncoding];
+    [cb commit];
+    [cb waitUntilCompleted];
+    if (cb.status == MTLCommandBufferStatusError) { fprintf(stderr, "qi35moe cb error: %s\n", cb.error.description.UTF8String); return -1; }
+    memcpy(sel_out, bSel.contents, 8 * 4);
+    memcpy(mq_out, bMq.contents, 2048 * 4);
+    memcpy(ms16_out, (char *)bXregs.contents + 201 * 16, 16);
+    return 0;
+}
+
+void qi35_moe_debug(long *tot_out, int *qdn_out, unsigned char *regs_out) {
+    memcpy(tot_out, bTot.contents, 2048 * 8);
+    memcpy(qdn_out, bQDn.contents, 9 * 2048 * 4);
+    memcpy(regs_out, bXregs.contents, 256 * 16);
+}
+void qi35_moe_debug_wn(long *wn_out) { memcpy(wn_out, qi35_bWn.contents, 8 * 8); }
diff --git a/docs/evidence/qi35_metal_shim.m b/docs/evidence/qi35_metal_shim.m
new file mode 100644
index 0000000000000000000000000000000000000000..fe32cdbc6fa0e1993f6894e4dc60f33043dd4ef5
--- /dev/null
+++ b/docs/evidence/qi35_metal_shim.m
@@ -0,0 +1,240 @@
+// qi35_metal_shim — Metal GEMM offload for the canonical integer engine (QI35-5 v1).
+// Bit-exact contract: kernels reproduce the CPU semantics exactly — Q4_K/Q6_K blocks are
+// decoded in-kernel with integer-only fp16 bit math, per-superblock partials are accumulated
+// into an exact 128-bit (lo,hi) pair with exponent alignment. Integer addition is associative,
+// so GPU thread order cannot change any bit of the result.
+// Build: clang -O2 -fobjc-arc -shared qi35_metal_shim.m -framework Metal -framework Foundation -o libqi35metal.dylib
+#import <Foundation/Foundation.h>
+#import <Metal/Metal.h>
+
+static id<MTLDevice> gDev;
+static id<MTLCommandQueue> gQueue;
+static id<MTLComputePipelineState> gPipeQ4K, gPipeQ6K;
+static NSMutableDictionary *gBufCache;   // @(aligned_ptr) -> MTLBuffer (no-copy, per tensor region)
+static id<MTLCommandBuffer> gCB;
+static id<MTLComputeCommandEncoder> gEnc;
+static NSMutableArray *gPendingOut;   // MTLBuffer outputs
+static NSMutableArray *gPendingDst;   // NSValue pointers
+static NSMutableArray *gPendingRows;  // NSNumber row counts
+static NSMutableArray *gXPool, *gOPool;
+static NSUInteger gXIdx, gOIdx;
+
+static id<MTLBuffer> poolBuf(NSMutableArray *pool, NSUInteger *idx, NSUInteger len) {
+    while (*idx < pool.count) {
+        id<MTLBuffer> b = pool[*idx];
+        if (b.length >= len) { (*idx)++; return b; }
+        (*idx)++;
+    }
+    id<MTLBuffer> b = [gDev newBufferWithLength:MAX(len, (NSUInteger)32768) options:MTLResourceStorageModeShared];
+    [pool addObject:b];
+    (*idx)++;
+    return b;
+}
+
+static NSString *const kSrc = @""
+"#include <metal_stdlib>\n"
+"using namespace metal;\n"
+"struct P { ulong toff; uint row0; uint rows; uint k; };\n"
+"struct O { ulong lo; long hi; int emin; int pad; };\n"
+"static inline void f16me(ushort b, thread long &m, thread int &e) {\n"
+"    int e5 = (b >> 10) & 31; long fr = b & 1023;\n"
+"    if (e5 == 0) { m = fr; e = -24; } else { m = 1024 + fr; e = e5 - 25; }\n"
+"    if (b & 0x8000) m = -m;\n"
+"}\n"
+"static inline void acc128(thread ulong &lo, thread long &hi, long a, int s) {\n"
+"    ulong lp; long hp;\n"
+"    if (s == 0) { lp = (ulong)a; hp = a < 0 ? -1 : 0; }\n"
+"    else { lp = ((ulong)a) << s; hp = a >> (64 - s); }\n"
+"    ulong nlo = lo + lp;\n"
+"    hi += hp + (nlo < lo ? 1 : 0);\n"
+"    lo = nlo;\n"
+"}\n"
+"kernel void gemm_q4k(device const uchar* W [[buffer(0)]],\n"
+"                     device const int* X [[buffer(1)]],\n"
+"                     device O* out [[buffer(2)]],\n"
+"                     constant P& p [[buffer(3)]],\n"
+"                     uint gid [[thread_position_in_grid]]) {\n"
+"    if (gid >= p.rows) return;\n"
+"    uint nsb = p.k / 256;\n"
+"    device const uchar* row = W + p.toff + (ulong)(p.row0 + gid) * nsb * 144;\n"
+"    long A[16]; int EA[16]; long B[16]; int EB[16];\n"
+"    int emin = 2147483647;\n"
+"    for (uint b = 0; b < nsb; b++) {\n"
+"        device const uchar* blk = row + b * 144;\n"
+"        long dm; int de; f16me((ushort)blk[0] | ((ushort)blk[1] << 8), dm, de);\n"
+"        long mm; int me; f16me((ushort)blk[2] | ((ushort)blk[3] << 8), mm, me);\n"
+"        long asum = 0, bsum = 0;\n"
+"        for (uint j = 0; j < 8; j++) {\n"
+"            long sc, mn;\n"
+"            if (j < 4) { sc = blk[4 + j] & 63; mn = blk[4 + j + 4] & 63; }\n"
+"            else { sc = (blk[4 + j + 4] & 0xF) | ((blk[4 + j - 4] >> 6) << 4);\n"
+"                   mn = (blk[4 + j + 4] >> 4) | ((blk[4 + j] >> 6) << 4); }\n"
+"            uint c = j / 2; uint hlf = j % 2;\n"
+"            device const uchar* qb = blk + 16 + 32 * c;\n"
+"            device const int* xv = X + b * 256 + 64 * c + 32 * hlf;\n"
+"            long dot = 0, sm = 0;\n"
+"            if (hlf == 0) {\n"
+"                for (uint l = 0; l < 32; l++) { int q = qb[l] & 0xF; int x = xv[l]; dot += q * x; sm += x; }\n"
+"            } else {\n"
+"                for (uint l = 0; l < 32; l++) { int q = qb[l] >> 4; int x = xv[l]; dot += q * x; sm += x; }\n"
+"            }\n"
+"            asum += sc * dot; bsum += mn * sm;\n"
+"        }\n"
+"        A[b] = dm * asum; EA[b] = de;\n"
+"        B[b] = mm * bsum; EB[b] = me;\n"
+"        if (A[b] != 0 && de < emin) emin = de;\n"
+"        if (B[b] != 0 && me < emin) emin = me;\n"
+"    }\n"
+"    if (emin == 2147483647) emin = 0;\n"
+"    ulong lo = 0; long hi = 0;\n"
+"    for (uint b = 0; b < nsb; b++) {\n"
+"        acc128(lo, hi, A[b], EA[b] - emin);\n"
+"        acc128(lo, hi, -B[b], EB[b] - emin);\n"
+"    }\n"
+"    out[gid].lo = lo; out[gid].hi = hi; out[gid].emin = emin; out[gid].pad = 0;\n"
+"}\n"
+"kernel void gemm_q6k(device const uchar* W [[buffer(0)]],\n"
+"                     device const int* X [[buffer(1)]],\n"
+"                     device O* out [[buffer(2)]],\n"
+"                     constant P& p [[buffer(3)]],\n"
+"                     uint gid [[thread_position_in_grid]]) {\n"
+"    if (gid >= p.rows) return;\n"
+"    uint nsb = p.k / 256;\n"
+"    device const uchar* row = W + p.toff + (ulong)(p.row0 + gid) * nsb * 210;\n"
+"    long A[16]; int EA[16];\n"
+"    int emin = 2147483647;\n"
+"    for (uint b = 0; b < nsb; b++) {\n"
+"        device const uchar* blk = row + b * 210;\n"
+"        device const uchar* ql = blk; device const uchar* qh = blk + 128;\n"
+"        long dm; int de; f16me((ushort)blk[208] | ((ushort)blk[209] << 8), dm, de);\n"
+"        long asum = 0;\n"
+"        for (uint hlf = 0; hlf < 2; hlf++) {\n"
+"            device const uchar* qlh = ql + 64 * hlf;\n"
+"            device const uchar* qhh = qh + 32 * hlf;\n"
+"            uint base = b * 256 + 128 * hlf;\n"
+"            uint sco = 8 * hlf;\n"
+"            for (uint l = 0; l < 32; l++) {\n"
+"                uint is = l / 16;\n"
+"                int q1 = (int)((qlh[l] & 0xF) | (((qhh[l] >> 0) & 3) << 4)) - 32;\n"
+"                int q2 = (int)((qlh[l + 32] & 0xF) | (((qhh[l] >> 2) & 3) << 4)) - 32;\n"
+"                int q3 = (int)((qlh[l] >> 4) | (((qhh[l] >> 4) & 3) << 4)) - 32;\n"
+"                int q4 = (int)((qlh[l + 32] >> 4) | (((qhh[l] >> 6) & 3) << 4)) - 32;\n"
+"                long d1 = (long)q1 * X[base + l];\n"
+"                long d2 = (long)q2 * X[base + l + 32];\n"
+"                long d3 = (long)q3 * X[base + l + 64];\n"
+"                long d4 = (long)q4 * X[base + l + 96];\n"
+"                asum += (long)(char)blk[192 + sco + is] * d1;\n"
+"                asum += (long)(char)blk[192 + sco + is + 2] * d2;\n"
+"                asum += (long)(char)blk[192 + sco + is + 4] * d3;\n"
+"                asum += (long)(char)blk[192 + sco + is + 6] * d4;\n"
+"            }\n"
+"        }\n"
+"        A[b] = dm * asum; EA[b] = de;\n"
+"        if (A[b] != 0 && de < emin) emin = de;\n"
+"    }\n"
+"    if (emin == 2147483647) emin = 0;\n"
+"    ulong lo = 0; long hi = 0;\n"
+"    for (uint b = 0; b < nsb; b++) acc128(lo, hi, A[b], EA[b] - emin);\n"
+"    out[gid].lo = lo; out[gid].hi = hi; out[gid].emin = emin; out[gid].pad = 0;\n"
+"}\n";
+
+typedef struct { unsigned long long toff; unsigned row0; unsigned rows; unsigned k; } GemmParams;
+
+int qi35_metal_init(const void *base, unsigned long long len) {
+    @autoreleasepool {
+        gDev = MTLCreateSystemDefaultDevice();
+        if (!gDev) return -1;
+        gQueue = [gDev newCommandQueue];
+        NSError *err = nil;
+        id<MTLLibrary> lib = [gDev newLibraryWithSource:kSrc options:nil error:&err];
+        if (!lib) { fprintf(stderr, "qi35metal: %s\n", err.description.UTF8String); return -2; }
+        gPipeQ4K = [gDev newComputePipelineStateWithFunction:[lib newFunctionWithName:@"gemm_q4k"] error:&err];
+        gPipeQ6K = [gDev newComputePipelineStateWithFunction:[lib newFunctionWithName:@"gemm_q6k"] error:&err];
+        if (!gPipeQ4K || !gPipeQ6K) return -3;
+        (void)base; (void)len;
+        fprintf(stderr, "qi35metal: maxBufferLength=%llu\n", (unsigned long long)gDev.maxBufferLength);
+        gBufCache = [NSMutableDictionary new];
+        gXPool = [NSMutableArray new]; gOPool = [NSMutableArray new];
+        gPendingOut = [NSMutableArray new];
+        gPendingDst = [NSMutableArray new];
+        gPendingRows = [NSMutableArray new];
+        return 0;
+    }
+}
+
+void qi35_metal_begin(void) {
+    gCB = [gQueue commandBuffer];
+    gEnc = [gCB computeCommandEncoderWithDispatchType:MTLDispatchTypeConcurrent];
+    gXIdx = 0; gOIdx = 0;
+    [gPendingOut removeAllObjects];
+    [gPendingDst removeAllObjects];
+    [gPendingRows removeAllObjects];
+}
+
+// per-tensor no-copy buffer over the mmap'd region (page-aligned start; delta carried in toff)
+static id<MTLBuffer> bufferFor(const void *w_ptr, unsigned long long w_len, unsigned long long *delta_out) {
+    unsigned long long page = (unsigned long long)getpagesize();
+    unsigned long long addr = (unsigned long long)w_ptr;
+    unsigned long long aligned = addr / page * page;
+    unsigned long long delta = addr - aligned;
+    unsigned long long rounded = (delta + w_len + page - 1) / page * page;
+    id<MTLBuffer> buf = gBufCache[@(aligned)];
+    if (!buf || buf.length < rounded) {
+        buf = [gDev newBufferWithBytesNoCopy:(void *)aligned length:rounded
+                                     options:MTLResourceStorageModeShared deallocator:nil];
+        if (!buf) { fprintf(stderr, "qi35metal: tensor buffer failed len=%llu\n", rounded); abort(); }
+        gBufCache[@(aligned)] = buf;
+    }
+    *delta_out = delta;
+    return buf;
+}
+
+// kind 0 = Q4_K, 1 = Q6_K. x: k int32 values. out: rows * 24 bytes {u64 lo, i64 hi, i32 emin, i32 pad}.
+void qi35_metal_gemm(int kind, const void *w_ptr, unsigned long long w_len, unsigned row0, unsigned rows,
+                     unsigned k, const int *x, void *out_dst) {
+    unsigned long long delta = 0;
+    id<MTLBuffer> wbuf = bufferFor(w_ptr, w_len, &delta);
+    id<MTLBuffer> xbuf = poolBuf(gXPool, &gXIdx, (NSUInteger)k * 4);
+    memcpy(xbuf.contents, x, (size_t)k * 4);
+    id<MTLBuffer> obuf = poolBuf(gOPool, &gOIdx, (NSUInteger)rows * 24);
+    GemmParams p = { delta, row0, rows, k };
+    [gEnc setComputePipelineState:(kind == 0 ? gPipeQ4K : gPipeQ6K)];
+    [gEnc setBuffer:wbuf offset:0 atIndex:0];
+    [gEnc setBuffer:xbuf offset:0 atIndex:1];
+    [gEnc setBuffer:obuf offset:0 atIndex:2];
+    [gEnc setBytes:&p length:sizeof(p) atIndex:3];
+    NSUInteger tg = 64;
+    MTLSize grid = MTLSizeMake(((rows + tg - 1) / tg) * tg, 1, 1);
+    [gEnc dispatchThreads:MTLSizeMake(rows, 1, 1) threadsPerThreadgroup:MTLSizeMake(tg, 1, 1)];
+    (void)grid;
+    [gPendingOut addObject:obuf];
+    [gPendingDst addObject:[NSValue valueWithPointer:out_dst]];
+    [gPendingRows addObject:@(rows)];
+}
+
+id<MTLDevice> qi35_dev(void) { return gDev; }
+id<MTLCommandQueue> qi35_queue(void) { return gQueue; }
+id<MTLBuffer> qi35_buffer_for(const void *w_ptr, unsigned long long w_len, unsigned long long *delta_out) {
+    return bufferFor(w_ptr, w_len, delta_out);
+}
+
+int qi35_metal_commit(void) {
+    [gEnc endEncoding];
+    [gCB commit];
+    [gCB waitUntilCompleted];
+    if (gCB.status == MTLCommandBufferStatusError) {
+        fprintf(stderr, "qi35metal: command buffer error: %s\n", gCB.error.description.UTF8String);
+        return -1;
+    }
+    for (NSUInteger i = 0; i < gPendingOut.count; i++) {
+        id<MTLBuffer> obuf = gPendingOut[i];
+        void *dst = [gPendingDst[i] pointerValue];
+        unsigned rows = [gPendingRows[i] unsignedIntValue];
+        memcpy(dst, obuf.contents, (size_t)rows * 24);
+    }
+    [gPendingOut removeAllObjects];
+    [gPendingDst removeAllObjects];
+    [gPendingRows removeAllObjects];
+    gCB = nil; gEnc = nil;
+    return 0;
+}
diff --git a/docs/evidence/qi35_model b/docs/evidence/qi35_model
new file mode 100644
index 0000000000000000000000000000000000000000..cd1db0f5a64c619d78c3ad039f2d987493948d49
--- /dev/null
+++ b/docs/evidence/qi35_model
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3cf902754d90bf29dc79c807e6b87cee274b50c612f53e8fa81cc63dd95300ce
+size 818504
diff --git a/docs/evidence/qi35_model.rs b/docs/evidence/qi35_model.rs
new file mode 100644
index 0000000000000000000000000000000000000000..409e7f13adff20d32d485bb91c0739c335a8c482
--- /dev/null
+++ b/docs/evidence/qi35_model.rs
@@ -0,0 +1,2004 @@
+// QI35-4: full-model canonical integer forward for Qwen3.6-35B-A3B (Q4_K_M blob, consumed directly).
+// Semantics = docs/canonical-integer-qwen36-design.md, validated at layer level by qi35_int_ref.py (G2).
+// No deps: raw mmap via libSystem, std::thread row-parallel GEMM (integer => order-free, bit-stable).
+// Build: rustc -O --edition 2021 qi35_model.rs -o qi35_model
+// Run:   ./qi35_model <model.gguf> <qi35_tables.bin> --ids 9419,11,1814 --ndecode 8 [--threads 8]
+
+#![allow(non_snake_case)]
+use std::collections::HashMap;
+use std::io::Read;
+
+const SC: u32 = 60;
+const HALF: i128 = 1 << 59;
+const ALVL: i128 = (1 << 23) - 1;
+const D: usize = 2048;
+const NL: usize = 40;
+const HK: usize = 16;
+const HV: usize = 32;
+const SDIM: usize = 128;
+const NH: usize = 16;
+const NKV: usize = 2;
+const HD: usize = 256;
+const NROT: usize = 64;
+const NEXP: usize = 256;
+const TOPK: usize = 8;
+const FEXP: usize = 512;
+const VOCAB: usize = 248320;
+const EPS_Q40: i128 = 1_099_512;
+const EPS_Q48: i128 = 281_474_977;
+
+fn rne(a: i128, s: u32) -> i128 { (a + (1i128 << (s - 1))) >> s }
+fn q60(m: i128, e: i32) -> i128 { let ee = e + SC as i32; if ee >= 0 { m << ee } else { rne(m, (-ee) as u32) } }
+fn apply(a: i128, s: i128) -> i128 { (a * s + HALF) >> SC }
+fn mul(a: i128, b: i128) -> i128 { (a * b + HALF) >> SC }
+fn sfrom(amax: i128, cur: i128) -> i128 { (amax / ALVL) * cur + ((amax % ALVL) * cur) / ALVL }
+fn fdiv(a: i128, b: i128) -> i128 { a.div_euclid(b) }
+fn isqrt(n: i128) -> i128 {
+    if n <= 0 { return 0; }
+    let mut x = n; let mut y = (x + 1) / 2;
+    while y < x { x = y; y = (x + n / x) / 2; }
+    x
+}
+fn f16_me(b: u16) -> (i64, i32) {
+    let s = (b >> 15) & 1; let e5 = ((b >> 10) & 31) as i32; let fr = (b & 1023) as i64;
+    let (m, e) = if e5 == 0 { (fr, -24) } else { (1024 + fr, e5 - 25) };
+    (if s == 1 { -m } else { m }, e)
+}
+fn f32_me(b: u32) -> (i64, i32) {
+    let s = (b >> 31) & 1; let e8 = ((b >> 23) & 255) as i32; let fr = (b & 0x7FFFFF) as i64;
+    let (m, e) = if e8 == 0 { (fr, -149) } else { ((1i64 << 23) + fr, e8 - 150) };
+    (if s == 1 { -m } else { m }, e)
+}
+fn f32_qfix(b: u32, q: i32) -> i128 {
+    let (m, e) = f32_me(b); let ee = e + q;
+    if ee >= 0 { (m as i128) << ee } else { rne(m as i128, (-ee) as u32) }
+}
+fn f16_qfix(b: u16, q: i32) -> i128 {
+    let (m, e) = f16_me(b); let ee = e + q;
+    if ee >= 0 { (m as i128) << ee } else { rne(m as i128, (-ee) as u32) }
+}
+
+// ---------- mmap ----------
+extern "C" {
+    fn mmap(addr: *mut u8, len: usize, prot: i32, flags: i32, fd: i32, off: i64) -> *mut u8;
+}
+fn map_file(path: &str) -> &'static [u8] {
+    use std::os::unix::io::AsRawFd;
+    let f = std::fs::File::open(path).unwrap();
+    let len = f.metadata().unwrap().len() as usize;
+    let p = unsafe { mmap(std::ptr::null_mut(), len, 1 /*PROT_READ*/, 1 /*MAP_SHARED*/, f.as_raw_fd(), 0) };
+    assert!(!p.is_null() && p as isize != -1, "mmap failed");
+    std::mem::forget(f);
+    unsafe { std::slice::from_raw_parts(p, len) }
+}
+
+// page-aligned zeroed allocation (anon mmap) — required so Metal can wrap the DeltaNet state
+// in no-copy buffers: GPU kernels and CPU fallback/shadow/state_root all touch the same bytes.
+fn page_alloc_i64(n: usize) -> &'static mut [i64] {
+    let len = (n * 8 + 16383) / 16384 * 16384; // 16K page multiple (Apple Silicon page size)
+    #[cfg(target_os = "macos")]
+    const AFLAGS: i32 = 0x1002; // MAP_ANON | MAP_PRIVATE
+    #[cfg(not(target_os = "macos"))]
+    const AFLAGS: i32 = 0x22; // MAP_ANONYMOUS | MAP_PRIVATE
+    let p = unsafe { mmap(std::ptr::null_mut(), len, 3 /*RW*/, AFLAGS, -1, 0) };
+    assert!(!p.is_null() && p as isize != -1, "anon mmap failed");
+    unsafe { std::slice::from_raw_parts_mut(p as *mut i64, n) }
+}
+
+// ---------- GGUF ----------
+struct TInfo { ne: Vec<usize>, ty: u32, off: usize }
+struct Gguf { data: &'static [u8], base: usize, dir: HashMap<String, TInfo> }
+// note: gemm_batch uses g.base + t.off as the absolute byte offset inside the whole-file GPU buffer
+impl Gguf {
+    fn open(path: &str) -> Gguf {
+        let data = map_file(path);
+        let rd_u32 = |p: &mut usize| { let v = u32::from_le_bytes(data[*p..*p+4].try_into().unwrap()); *p += 4; v };
+        let rd_u64 = |p: &mut usize| { let v = u64::from_le_bytes(data[*p..*p+8].try_into().unwrap()); *p += 8; v };
+        let mut p = 4usize; // "GGUF"
+        assert_eq!(&data[0..4], b"GGUF");
+        let _ver = rd_u32(&mut p);
+        let tcount = rd_u64(&mut p) as usize;
+        let kvcount = rd_u64(&mut p) as usize;
+        let rd_str = |p: &mut usize| -> String {
+            let n = u64::from_le_bytes(data[*p..*p+8].try_into().unwrap()) as usize; *p += 8;
+            let s = String::from_utf8_lossy(&data[*p..*p+n]).into_owned(); *p += n; s
+        };
+        let mut align = 32usize;
+        fn skip_val(data: &[u8], p: &mut usize, vt: u32) -> Option<u64> {
+            match vt {
+                0 | 1 | 7 => { *p += 1; None }
+                2 | 3 => { *p += 2; None }
+                4 | 5 | 6 => { let v = u32::from_le_bytes(data[*p..*p+4].try_into().unwrap()); *p += 4; Some(v as u64) }
+                10 | 11 | 12 => { let v = u64::from_le_bytes(data[*p..*p+8].try_into().unwrap()); *p += 8; Some(v) }
+                8 => { let n = u64::from_le_bytes(data[*p..*p+8].try_into().unwrap()) as usize; *p += 8 + n; None }
+                9 => {
+                    let et = u32::from_le_bytes(data[*p..*p+4].try_into().unwrap()); *p += 4;
+                    let cnt = u64::from_le_bytes(data[*p..*p+8].try_into().unwrap()); *p += 8;
+                    for _ in 0..cnt { skip_val(data, p, et); }
+                    None
+                }
+                _ => panic!("vt {}", vt),
+            }
+        }
+        for _ in 0..kvcount {
+            let key = rd_str(&mut p);
+            let vt = rd_u32(&mut p);
+            let v = skip_val(data, &mut p, vt);
+            if key == "general.alignment" { if let Some(a) = v { align = a as usize; } }
+        }
+        let mut dir = HashMap::new();
+        for _ in 0..tcount {
+            let name = rd_str(&mut p);
+            let nd = rd_u32(&mut p) as usize;
+            let mut ne = Vec::with_capacity(nd);
+            for _ in 0..nd { ne.push(rd_u64(&mut p) as usize); }
+            let ty = rd_u32(&mut p);
+            let off = rd_u64(&mut p) as usize;
+            dir.insert(name, TInfo { ne, ty, off });
+        }
+        let base = (p + align - 1) / align * align;
+        Gguf { data, base, dir }
+    }
+    fn t(&self, name: &str) -> &TInfo { self.dir.get(name).unwrap_or_else(|| panic!("missing tensor {}", name)) }
+    fn bytes(&self, name: &str, off: usize, n: usize) -> &[u8] {
+        let t = self.t(name);
+        &self.data[self.base + t.off + off..self.base + t.off + off + n]
+    }
+}
+
+// ---------- tables ----------
+struct Tables { sig: Vec<i64>, softplus: Vec<i64>, expn: Vec<i64>, gamma: Vec<i64>, cos: Vec<i64>, sin: Vec<i64>, smax: usize }
+fn load_tables(path: &str) -> Tables {
+    let mut buf = Vec::new();
+    std::fs::File::open(path).unwrap().read_to_end(&mut buf).unwrap();
+    assert_eq!(&buf[0..8], b"QI35TBL1");
+    let smax = u32::from_le_bytes(buf[8..12].try_into().unwrap()) as usize;
+    let mut p = 16usize;
+    let mut rd = |n: usize| -> Vec<i64> {
+        let v: Vec<i64> = buf[p..p + 8 * n].chunks(8).map(|c| i64::from_le_bytes(c.try_into().unwrap())).collect();
+        p += 8 * n; v
+    };
+    let sig = rd(16384); let softplus = rd(16384); let expn = rd(16384); let gamma = rd(32769);
+    let cos = rd(smax * 32); let sin = rd(smax * 32);
+    Tables { sig, softplus, expn, gamma, cos, sin, smax }
+}
+impl Tables {
+    fn sig_at(&self, xq16: i128) -> i64 {
+        let i = rne(xq16, 7) + 8192;
+        self.sig[i.clamp(0, 16383) as usize]
+    }
+    fn silu_q16(&self, xq16: i128) -> i128 { (xq16 * self.sig_at(xq16) as i128) >> 16 }
+    fn softplus_at(&self, xq16: i128) -> i128 {
+        if xq16 > (20i128 << 16) { return xq16; }
+        let i = rne(xq16, 7) + 8192;
+        self.softplus[i.clamp(0, 16383) as usize] as i128
+    }
+    fn expn_at(&self, idx: i128) -> i64 { if idx < 0 { self.expn[0] } else if idx < 16384 { self.expn[idx as usize] } else { 0 } }
+    fn gamma_at(&self, idx: i128) -> i64 { if idx <= 32768 { self.gamma[idx.max(0) as usize] } else { 0 } }
+}
+
+// ---------- Metal offload (QI35-5 v1): big GEMMs on GPU, integer glue on CPU ----------
+#[repr(C)]
+struct MetalOut { lo: u64, hi: i64, emin: i32, pad: i32 }
+#[cfg(target_os = "macos")]
+#[link(name = "qi35metal")]
+extern "C" {
+    fn qi35_metal_init(base: *const u8, len: u64) -> i32;
+    fn qi35_metal_begin();
+    fn qi35_metal_gemm(kind: i32, w_ptr: *const u8, w_len: u64, row0: u32, rows: u32, k: u32, x: *const i32, out: *mut u8);
+    fn qi35_metal_commit() -> i32;
+}
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_metal_init(_base: *const u8, _len: u64) -> i32 { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_metal_begin() { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_metal_gemm(
+    _kind: i32,
+    _w_ptr: *const u8,
+    _w_len: u64,
+    _row0: u32,
+    _rows: u32,
+    _k: u32,
+    _x: *const i32,
+    _out: *mut u8,
+) { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_metal_commit() -> i32 { unreachable!("Metal is macOS-only") }
+static mut METAL: bool = false;
+static mut METAL_V3: bool = false;
+const GPU_MIN_ROWS: usize = 256;
+#[repr(C)]
+struct MoeTensors {
+    gate_ptr: *const u8, gate_len: u64, gate_off_unused: u64,
+    up_ptr: *const u8, up_len: u64,
+    down_ptr: *const u8, down_len: u64,
+    gsh_ptr: *const u8, gsh_len: u64,
+    ush_ptr: *const u8, ush_len: u64,
+    dsh_ptr: *const u8, dsh_len: u64,
+    layer: u32,
+}
+#[cfg(target_os = "macos")]
+extern "C" {
+    fn qi35_moe_init(sig: *const i64, expn: *const i64) -> i32;
+    fn qi35_moe_upload_router(layer: u32, router: *const i64, shw: *const i64);
+    fn qi35_moe_run(t: *const MoeTensors, xq: *const i32, xs16: *const u8,
+                    sel_out: *mut u32, mq_out: *mut i32, ms16_out: *mut u8) -> i32;
+    fn qi35_moe_debug(tot_out: *mut i64, qdn_out: *mut i32, regs_out: *mut u8);
+    fn qi35_moe_debug_wn(wn_out: *mut i64);
+}
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_moe_init(_sig: *const i64, _expn: *const i64) -> i32 { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_moe_upload_router(_layer: u32, _router: *const i64, _shw: *const i64) { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_moe_run(
+    _t: *const MoeTensors,
+    _xq: *const i32,
+    _xs16: *const u8,
+    _sel_out: *mut u32,
+    _mq_out: *mut i32,
+    _ms16_out: *mut u8,
+) -> i32 { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_moe_debug(_tot_out: *mut i64, _qdn_out: *mut i32, _regs_out: *mut u8) { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_moe_debug_wn(_wn_out: *mut i64) { unreachable!("Metal is macOS-only") }
+// ---------- Metal on-device DeltaNet (QI35-5 v3 Phase B) ----------
+#[repr(C)]
+struct DnTensors { ptr: [*const u8; 5], len: [u64; 5], ty: [u32; 5], layer: u32 } // qkv, gate, beta, alpha, out
+#[cfg(target_os = "macos")]
+extern "C" {
+    fn qi35_dn_init(sig: *const i64, softplus: *const i64, gamma: *const i64) -> i32;
+    fn qi35_dn_upload_layer(layer: u32, w30: *const i64, nrm: *const i64, dt16: *const i64, a30: *const i64);
+    fn qi35_dn_bind_state(layer: u32, s_ptr: *mut i64, s_len: u64, conv_ptr: *mut i64, conv_len: u64) -> i32;
+    fn qi35_dn_run(t: *const DnTensors, xq: *const i32, xs16: *const u8, mq_out: *mut i32, ms16_out: *mut u8) -> i32;
+    fn qi35_dn_debug(convs: *mut i64, qk: *mut i64, o24: *mut i64, y16: *mut u8, yq: *mut i32, regs: *mut u8);
+}
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_dn_init(_sig: *const i64, _softplus: *const i64, _gamma: *const i64) -> i32 { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_dn_upload_layer(
+    _layer: u32,
+    _w30: *const i64,
+    _nrm: *const i64,
+    _dt16: *const i64,
+    _a30: *const i64,
+) { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_dn_bind_state(
+    _layer: u32,
+    _s_ptr: *mut i64,
+    _s_len: u64,
+    _conv_ptr: *mut i64,
+    _conv_len: u64,
+) -> i32 { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_dn_run(
+    _t: *const DnTensors,
+    _xq: *const i32,
+    _xs16: *const u8,
+    _mq_out: *mut i32,
+    _ms16_out: *mut u8,
+) -> i32 { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_dn_debug(
+    _convs: *mut i64,
+    _qk: *mut i64,
+    _o24: *mut i64,
+    _y16: *mut u8,
+    _yq: *mut i32,
+    _regs: *mut u8,
+) { unreachable!("Metal is macOS-only") }
+// CPU-side stage stash for the DeltaNet shadow comparison (filled only under QI35_SHADOW)
+struct DnStash {
+    convs: Vec<i64>, qk: Vec<i64>, o24: Vec<i128>, y: Vec<i128>, yq: Vec<i64>,
+    s_qkv: i128, s_z: i128, s_b: i128, s_a: i128, ys: i128,
+    beta16: Vec<i128>, gam30: Vec<i128>,
+}
+static mut DN_STASH: Option<DnStash> = None;
+static GPU_DN_NS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+// ---------- Metal on-device full attention (QI35-5 v3 Phase C) ----------
+#[repr(C)]
+struct AtTensors { ptr: [*const u8; 4], len: [u64; 4], ty: [u32; 4], layer: u32, pos: u32 } // q, k, v, out
+#[cfg(target_os = "macos")]
+extern "C" {
+    fn qi35_at_init(sig: *const i64, expn: *const i64, cos: *const i64, sin: *const i64, smax: u32) -> i32;
+    fn qi35_at_upload_layer(layer: u32, qnorm30: *const i64, knorm30: *const i64);
+    fn qi35_at_bind_kv(layer: u32, k_ptr: *mut i64, k_len: u64, v_ptr: *mut i64, v_len: u64) -> i32;
+    fn qi35_at_run(t: *const AtTensors, xq: *const i32, xs16: *const u8, mq_out: *mut i32, ms16_out: *mut u8) -> i32;
+    fn qi35_at_debug(qn: *mut u8, kn: *mut u8, qnq: *mut i32, knq: *mut i32,
+                     att: *mut u8, atq: *mut i32, regs: *mut u8,
+                     scr: *mut u8, es: *mut u8, tlen: u64);
+}
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_at_init(
+    _sig: *const i64,
+    _expn: *const i64,
+    _cos: *const i64,
+    _sin: *const i64,
+    _smax: u32,
+) -> i32 { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_at_upload_layer(_layer: u32, _qnorm30: *const i64, _knorm30: *const i64) { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_at_bind_kv(
+    _layer: u32,
+    _k_ptr: *mut i64,
+    _k_len: u64,
+    _v_ptr: *mut i64,
+    _v_len: u64,
+) -> i32 { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_at_run(
+    _t: *const AtTensors,
+    _xq: *const i32,
+    _xs16: *const u8,
+    _mq_out: *mut i32,
+    _ms16_out: *mut u8,
+) -> i32 { unreachable!("Metal is macOS-only") }
+#[cfg(not(target_os = "macos"))]
+unsafe fn qi35_at_debug(
+    _qn: *mut u8,
+    _kn: *mut u8,
+    _qnq: *mut i32,
+    _knq: *mut i32,
+    _att: *mut u8,
+    _atq: *mut i32,
+    _regs: *mut u8,
+    _scr: *mut u8,
+    _es: *mut u8,
+    _tlen: u64,
+) { unreachable!("Metal is macOS-only") }
+// CPU-side stage stash for the attention shadow comparison (filled only under QI35_SHADOW)
+struct AtStash {
+    qn: Vec<i128>, kn: Vec<i128>, qr: Vec<i64>, kr: Vec<i64>,
+    att: Vec<i128>, atq: Vec<i64>, scr: Vec<i128>, es: Vec<i128>,
+    s_qf: i128, s_k: i128, s_v: i128, qn_s: i128, kn_s: i128, at_s: i128, cq: i128,
+}
+static mut AT_STASH: Option<AtStash> = None;
+static GPU_AT_NS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+// QI35_AT_CPU=1: keep attention on the Phase-B path (gemm_batch + CPU glue) even under --metal-v3.
+// perf-isolation switch; bit-exactness is identical either way.
+fn at_cpu() -> bool {
+    static V: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *V.get_or_init(|| std::env::var("QI35_AT_CPU").is_ok())
+}
+// QI35_KVMAX: pre-allocated KV rows per attention layer (default: tables smax)
+fn kvmax_env(smax: usize) -> usize {
+    std::env::var("QI35_KVMAX").ok().and_then(|v| v.parse().ok()).unwrap_or(smax).min(smax)
+}
+// QI35_KVBIND0: initial GPU-bound KV rows (default 1024). Measured: large tracked no-copy
+// buffers tax EVERY command buffer's commit (moe 151ms -> 1.5s/token at 8192 rows bound);
+// so the GPU binding starts small and grows x4 by re-wrapping the same pages when pos demands.
+fn kvbind0() -> usize {
+    static V: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
+    *V.get_or_init(|| std::env::var("QI35_KVBIND0").ok().and_then(|v| v.parse().ok()).unwrap_or(1024))
+}
+// bind length must keep the byte length a 16K multiple: rows*NKV*HD*8 = rows*4096 -> rows % 4 == 0
+fn round4(n: usize) -> usize { (n + 3) / 4 * 4 }
+static mut DBG_DS: Vec<i128> = Vec::new();
+static mut DBG_WN: Vec<i128> = Vec::new();
+static mut DBG_STASH: Option<(Vec<i64>, Vec<i128>, i128, i128, Vec<i128>)> = None; // (dq flat 9*2048, acc_s 9, smax1, smax2, tot 2048)
+fn i128_to16(v: i128) -> [u8; 16] { v.to_le_bytes() }
+fn i128_from16(b: &[u8]) -> i128 { i128::from_le_bytes(b[0..16].try_into().unwrap()) }
+static GPU_NS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+static GPU_COMMITS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+static GPU_XCONV_NS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+
+// ---------- parallel helper: persistent pool (thread spawn per call was measured too slow) ----------
+static mut NTHREADS: usize = 8;
+
+struct PoolJob { f: *const (dyn Fn(usize) + Sync), start: usize, end: usize, done: *const std::sync::atomic::AtomicUsize }
+unsafe impl Send for PoolJob {}
+struct Pool { senders: Vec<std::sync::mpsc::Sender<PoolJob>> }
+static POOL: std::sync::OnceLock<Pool> = std::sync::OnceLock::new();
+
+fn pool() -> &'static Pool {
+    POOL.get_or_init(|| {
+        let nt = unsafe { NTHREADS }.max(2) - 1; // main thread takes one chunk itself
+        let mut senders = Vec::with_capacity(nt);
+        for _ in 0..nt {
+            let (tx, rx) = std::sync::mpsc::channel::<PoolJob>();
+            std::thread::spawn(move || {
+                while let Ok(job) = rx.recv() {
+                    let f = unsafe { &*job.f };
+                    for i in job.start..job.end { f(i); }
+                    unsafe { &*job.done }.fetch_add(1, std::sync::atomic::Ordering::Release);
+                }
+            });
+            senders.push(tx);
+        }
+        Pool { senders }
+    })
+}
+
+// run f(i) for i in 0..n across the pool; blocks until complete. f may write disjoint
+// indices of shared output via raw pointers (integer semantics stay bit-exact: pure map).
+fn parallel_for(n: usize, f: &(dyn Fn(usize) + Sync)) {
+    if n == 0 { return; }
+    if n < 64 { for i in 0..n { f(i); } return; }
+    let p = pool();
+    let nw = p.senders.len();
+    let parts = (nw + 1).min(n);
+    let chunk = (n + parts - 1) / parts;
+    let done = std::sync::atomic::AtomicUsize::new(0);
+    // lifetime erasure is sound: this function blocks until every worker acked (done == sent)
+    let fp: *const (dyn Fn(usize) + Sync + 'static) = unsafe { std::mem::transmute(f) };
+    let mut sent = 0usize;
+    let mut start = chunk; // chunk 0 runs on the main thread
+    for s in &p.senders {
+        if start >= n { break; }
+        let end = (start + chunk).min(n);
+        s.send(PoolJob { f: fp, start, end, done: &done }).unwrap();
+        sent += 1;
+        start = end;
+    }
+    for i in 0..chunk.min(n) { f(i); }
+    let mut spins = 0u32;
+    while done.load(std::sync::atomic::Ordering::Acquire) < sent {
+        spins += 1;
+        if spins > 10_000 { std::thread::yield_now(); } else { std::hint::spin_loop(); }
+    }
+}
+
+fn par_chunks<T: Send>(out: &mut [T], f: impl Fn(usize, &mut T) + Sync) {
+    let n = out.len();
+    let base = out.as_mut_ptr() as usize;
+    let g = move |i: usize| {
+        let item = unsafe { &mut *(base as *mut T).add(i) };
+        f(i, item);
+    };
+    parallel_for(n, &g);
+}
+
+// ---------- exact integer GEMM on Q4_K / Q6_K ----------
+// GPU batch: all items encoded in ONE command buffer / one commit (dispatch-latency amortization).
+// Falls back to the CPU path when Metal is off. Bit-identical either way (integer associativity).
+fn gemm_batch(g: &Gguf, items: &[(&str, usize, usize, &[i64])]) -> Vec<Vec<(i128, i32)>> {
+    let use_gpu = unsafe { METAL } && items.iter().any(|&(_, _, rows, _)| rows >= GPU_MIN_ROWS);
+    if !use_gpu {
+        return items.iter().map(|&(n, r0, r, x)| gemm_rows_cpu(g, n, r0, r, x)).collect();
+    }
+    let t0 = std::time::Instant::now();
+    let mut outs: Vec<Vec<MetalOut>> = Vec::with_capacity(items.len());
+    let mut xis: Vec<Vec<i32>> = Vec::with_capacity(items.len());
+    let mut cpu_slots: Vec<Option<Vec<(i128, i32)>>> = Vec::with_capacity(items.len());
+    unsafe { qi35_metal_begin(); }
+    for &(name, row0, rows, x) in items {
+        if rows < GPU_MIN_ROWS {
+            cpu_slots.push(Some(gemm_rows_cpu(g, name, row0, rows, x)));
+            outs.push(Vec::new()); xis.push(Vec::new());
+            continue;
+        }
+        cpu_slots.push(None);
+        let t = g.t(name);
+        let k = t.ne[0];
+        assert_eq!(x.len(), k);
+        let kind = match t.ty { 12 => 0i32, 14 => 1i32, _ => panic!("gemm on type {}", t.ty) };
+        assert!(k / 256 <= 16, "kernel superblock capacity exceeded (k={})", k);
+        let blocksz = if t.ty == 12 { 144 } else { 210 };
+        let total_rows: usize = t.ne[1..].iter().product();
+        let w_len = (total_rows * (k / 256) * blocksz) as u64;
+        let w_ptr = unsafe { g.data.as_ptr().add(g.base + t.off) };
+        let xi: Vec<i32> = x.iter().map(|&v| { debug_assert!(v.abs() <= (1 << 24)); v as i32 }).collect();
+        let mut out: Vec<MetalOut> = Vec::with_capacity(rows);
+        unsafe {
+            out.set_len(rows);
+            qi35_metal_gemm(kind, w_ptr, w_len, row0 as u32, rows as u32, k as u32,
+                            xi.as_ptr(), out.as_mut_ptr().cast());
+        }
+        xis.push(xi);
+        outs.push(out);
+    }
+    unsafe { assert_eq!(qi35_metal_commit(), 0, "metal commit failed"); }
+    GPU_NS.fetch_add(t0.elapsed().as_nanos() as u64, std::sync::atomic::Ordering::Relaxed);
+    GPU_COMMITS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    items.iter().enumerate().map(|(i, _)| {
+        if let Some(cpu) = cpu_slots[i].take() { return cpu; }
+        outs[i].iter().map(|o| ((i128::from(o.hi) << 64) | i128::from(o.lo), o.emin)).collect()
+    }).collect()
+}
+
+fn gemm_rows(g: &Gguf, name: &str, row0: usize, rows: usize, x: &[i64]) -> Vec<(i128, i32)> {
+    if unsafe { METAL } && rows >= GPU_MIN_ROWS {
+        return gemm_batch(g, &[(name, row0, rows, x)]).pop().unwrap();
+    }
+    gemm_rows_cpu(g, name, row0, rows, x)
+}
+
+// returns per-row (acc: i128, emin: i32) with row value = acc * 2^emin (in x-int units)
+fn gemm_rows_cpu(g: &Gguf, name: &str, row0: usize, rows: usize, x: &[i64]) -> Vec<(i128, i32)> {
+    let t = g.t(name);
+    let k = t.ne[0];
+    assert_eq!(x.len(), k);
+    let mut out: Vec<(i128, i32)> = vec![(0, 0); rows];
+    match t.ty {
+        12 => { // Q4_K, 144B per 256
+            let nsb = k / 256;
+            par_chunks(&mut out, |r, slot| {
+                let raw = g.bytes(name, (row0 + r) * nsb * 144, nsb * 144);
+                let mut terms: Vec<(i64, i32, i64, i32)> = Vec::with_capacity(nsb);
+                let mut emin = i32::MAX;
+                for b in 0..nsb {
+                    let blk = &raw[b * 144..(b + 1) * 144];
+                    let (dm, de) = f16_me(u16::from_le_bytes(blk[0..2].try_into().unwrap()));
+                    let (mm, me) = f16_me(u16::from_le_bytes(blk[2..4].try_into().unwrap()));
+                    let scl = &blk[4..16];
+                    let qs = &blk[16..144];
+                    let mut asum = 0i64; let mut bsum = 0i64;
+                    for j in 0..8 {
+                        let (sc, mn) = if j < 4 {
+                            ((scl[j] & 63) as i64, (scl[j + 4] & 63) as i64)
+                        } else {
+                            ((((scl[j + 4] & 0xF) | ((scl[j - 4] >> 6) << 4))) as i64,
+                             (((scl[j + 4] >> 4) | ((scl[j] >> 6) << 4))) as i64)
+                        };
+                        // values for sub-block j live at chunk c=j/2, half=j%2
+                        let c = j / 2; let half = j % 2;
+                        let qb = &qs[32 * c..32 * c + 32];
+                        let xoff = b * 256 + 64 * c + 32 * half;
+                        let mut dot = 0i64; let mut sm = 0i64;
+                        if half == 0 {
+                            for l in 0..32 { let qv = (qb[l] & 0xF) as i64; let xv = x[xoff + l]; dot += qv * xv; sm += xv; }
+                        } else {
+                            for l in 0..32 { let qv = (qb[l] >> 4) as i64; let xv = x[xoff + l]; dot += qv * xv; sm += xv; }
+                        }
+                        asum += sc * dot; bsum += mn * sm;
+                    }
+                    let a = dm * asum; let bb = mm * bsum;
+                    if a != 0 && de < emin { emin = de; }
+                    if bb != 0 && me < emin { emin = me; }
+                    terms.push((a, de, bb, me));
+                }
+                if emin == i32::MAX { emin = 0; }
+                let mut acc: i128 = 0;
+                for (a, de, bb, me) in terms {
+                    acc += (a as i128) << (de - emin);
+                    acc -= (bb as i128) << (me - emin);
+                }
+                *slot = (acc, emin);
+            });
+        }
+        14 => { // Q6_K, 210B per 256
+            let nsb = k / 256;
+            par_chunks(&mut out, |r, slot| {
+                let raw = g.bytes(name, (row0 + r) * nsb * 210, nsb * 210);
+                let mut terms: Vec<(i64, i32)> = Vec::with_capacity(nsb);
+                let mut emin = i32::MAX;
+                for b in 0..nsb {
+                    let blk = &raw[b * 210..(b + 1) * 210];
+                    let ql = &blk[0..128]; let qh = &blk[128..192];
+                    let scs = &blk[192..208];
+                    let (dm, de) = f16_me(u16::from_le_bytes(blk[208..210].try_into().unwrap()));
+                    let mut asum = 0i64;
+                    for half in 0..2 {
+                        let qlh = &ql[64 * half..64 * half + 64];
+                        let qhh = &qh[32 * half..32 * half + 32];
+                        let base = b * 256 + 128 * half;
+                        let sco = 8 * half;
+                        for l in 0..32 {
+                            let is = l / 16;
+                            let q1 = ((qlh[l] & 0xF) as i64 | ((((qhh[l] >> 0) & 3) as i64) << 4)) - 32;
+                            let q2 = ((qlh[l + 32] & 0xF) as i64 | ((((qhh[l] >> 2) & 3) as i64) << 4)) - 32;
+                            let q3 = ((qlh[l] >> 4) as i64 | ((((qhh[l] >> 4) & 3) as i64) << 4)) - 32;
+                            let q4 = ((qlh[l + 32] >> 4) as i64 | ((((qhh[l] >> 6) & 3) as i64) << 4)) - 32;
+                            asum += (scs[sco + is] as i8 as i64) * q1 * x[base + l];
+                            asum += (scs[sco + is + 2] as i8 as i64) * q2 * x[base + l + 32];
+                            asum += (scs[sco + is + 4] as i8 as i64) * q3 * x[base + l + 64];
+                            asum += (scs[sco + is + 6] as i8 as i64) * q4 * x[base + l + 96];
+                        }
+                    }
+                    let a = dm.checked_mul(asum).expect("q6k ovf");
+                    if a != 0 && de < emin { emin = de; }
+                    terms.push((a, de));
+                }
+                if emin == i32::MAX { emin = 0; }
+                let mut acc: i128 = 0;
+                for (a, de) in terms { acc += (a as i128) << (de - emin); }
+                *slot = (acc, emin);
+            });
+        }
+        _ => panic!("gemm on type {}", t.ty),
+    }
+    out
+}
+
+// per-token A24 quantization
+fn aq_row(v: &[i128], cur: i128) -> (Vec<i64>, i128) {
+    let amax = v.iter().map(|x| x.abs()).max().unwrap_or(0).max(1);
+    let q = v.iter().map(|&x| {
+        let sg = if x > 0 { amax } else if x < 0 { -amax } else { 0 };
+        fdiv(x * ALVL * 2 + sg, 2 * amax) as i64
+    }).collect();
+    (q, sfrom(amax, cur))
+}
+
+// hifi-style projection: GEMM + per-row Q60 scale + requant + per-token aq
+fn proj(g: &Gguf, name: &str, row0: usize, rows: usize, xq: &[i64], xs: i128) -> (Vec<i64>, i128) {
+    let rowsres = gemm_rows(g, name, row0, rows, xq);
+    proj_finish(rowsres, xs)
+}
+fn proj_finish(rowsres: Vec<(i128, i32)>, xs: i128) -> (Vec<i64>, i128) {
+    let colsq: Vec<i128> = rowsres.iter().map(|&(_, e)| mul(xs, q60(1, e))).collect();
+    let cmax = *colsq.iter().max().unwrap().max(&1);
+    let resc: Vec<i128> = rowsres.iter().zip(&colsq).map(|(&(acc, _), &cs)| {
+        apply(acc, (cs << SC) / cmax)
+    }).collect();
+    aq_row(&resc, cmax)
+}
+
+fn to_fix(a: i128, s: i128, outq: u32) -> i128 { rne(a * s, SC - outq) }
+
+// RMSNorm over a full vector with pinned eps (per-token); returns A24 + Q60 scale
+fn rms_q(g: &Gguf, hq: &[i128], s_h: i128, gam: &[i128]) -> (Vec<i64>, i128) {
+    let n = hq.len() as i128;
+    let ss: i128 = hq.iter().map(|&x| x * x).sum();
+    let u = ((1i128 << 60) / s_h).min(1i128 << 40);
+    let eps = (EPS_Q40 * u * u) >> 40;
+    let mean = ss / n + eps + 1;
+    let inv = isqrt((1i128 << 88) / mean);
+    // normalize products to <=2^52 before aq (pinned RNE; keeps everything in i128)
+    let yg: Vec<i128> = hq.iter().zip(gam).map(|(&h, &gm)| rne(h * inv * gm, 30)).collect();
+    let (q, s0) = aq_row(&yg, 1i128 << SC);
+    (q, rne(s0, 44))
+}
+// per-head rms over Q24 fixed ints (DeltaNet o-norm), returns ints at 2^-74 unit
+fn rms_perhead_q24(vals: &[i128], gam: &[i128]) -> Vec<i128> {
+    let n = vals.len() as i128;
+    let ss: i128 = vals.iter().map(|&x| x * x).sum();
+    let mean = ss / n + EPS_Q48 + 1;
+    let inv = isqrt((1i128 << 88) / mean);
+    vals.iter().zip(gam).map(|(&v, &gm)| rne(v * inv * gm, 30)).collect()
+}
+// per-head rms over A24 slice with per-token eps (q/k norm); ints at 2^-74 unit
+fn rms_perhead_a24(vals: &[i64], s: i128, gam: &[i128]) -> Vec<i128> {
+    let n = vals.len() as i128;
+    let ss: i128 = vals.iter().map(|&x| (x as i128) * (x as i128)).sum();
+    let u = ((1i128 << 60) / s).min(1i128 << 40);
+    let eps = (EPS_Q40 * u * u) >> 40;
+    let mean = ss / n + eps + 1;
+    let inv = isqrt((1i128 << 88) / mean);
+    vals.iter().zip(gam).map(|(&v, &gm)| rne((v as i128) * inv * gm, 30)).collect()
+}
+
+// ---------- per-layer cached small weights ----------
+struct LayerW {
+    attn_norm: Vec<i128>, post_norm: Vec<i128>,
+    // deltanet
+    ssm_norm: Vec<i128>, ssm_dt16: Vec<i128>, ssm_a30: Vec<i128>, convw30: Vec<i128>, // [8192*4]
+    // attention
+    qnorm: Vec<i128>, knorm: Vec<i128>,
+    is_attn: bool,
+    router30: Vec<i64>,   // [NEXP*D] ffn_gate_inp Q30
+    shexp30: Vec<i64>,    // [D] ffn_gate_inp_shexp Q30
+}
+fn load_f32_vec(g: &Gguf, name: &str, q: i32) -> Vec<i128> {
+    let t = g.t(name);
+    let n: usize = t.ne.iter().product();
+    match t.ty {
+        0 => g.bytes(name, 0, n * 4).chunks(4).map(|c| f32_qfix(u32::from_le_bytes(c.try_into().unwrap()), q)).collect(),
+        1 => g.bytes(name, 0, n * 2).chunks(2).map(|c| f16_qfix(u16::from_le_bytes(c.try_into().unwrap()), q)).collect(),
+        _ => panic!("f32vec type"),
+    }
+}
+fn load_layer(g: &Gguf, l: usize) -> LayerW {
+    let is_attn = (l + 1) % 4 == 0;
+    let p = format!("blk.{}.", l);
+    let mut w = LayerW {
+        attn_norm: load_f32_vec(g, &format!("{}attn_norm.weight", p), 30),
+        post_norm: load_f32_vec(g, &format!("{}post_attention_norm.weight", p), 30),
+        ssm_norm: vec![], ssm_dt16: vec![], ssm_a30: vec![], convw30: vec![],
+        qnorm: vec![], knorm: vec![], is_attn,
+        router30: load_f32_vec(g, &format!("{}ffn_gate_inp.weight", p), 30).iter().map(|&v| i64::try_from(v).unwrap()).collect(),
+        shexp30: load_f32_vec(g, &format!("{}ffn_gate_inp_shexp.weight", p), 30).iter().map(|&v| i64::try_from(v).unwrap()).collect(),
+    };
+    if is_attn {
+        w.qnorm = load_f32_vec(g, &format!("{}attn_q_norm.weight", p), 30);
+        w.knorm = load_f32_vec(g, &format!("{}attn_k_norm.weight", p), 30);
+    } else {
+        w.ssm_norm = load_f32_vec(g, &format!("{}ssm_norm.weight", p), 30);
+        w.ssm_dt16 = load_f32_vec(g, &format!("{}ssm_dt", p), 16);
+        w.ssm_a30 = load_f32_vec(g, &format!("{}ssm_a", p), 30);
+        w.convw30 = load_f32_vec(g, &format!("{}ssm_conv1d.weight", p), 30); // [8192 rows? ne=[4,8192]] flat: idx = ch*4+tap? ne0=4 fastest => flat[ch*4+tap]
+    }
+    w
+}
+
+// ---------- states ----------
+// s: [HV*SDIM*SDIM] Q24 (S[h][i][j]); conv ring [3*8192] Q16 — page-aligned so the GPU can own it in place
+struct DState { s: &'static mut [i64], conv: &'static mut [i64] }
+// KV cache: pre-allocated at smax rows (page-aligned) so the GPU owns it in place (v3 Phase C).
+// Layout per token t: [(t*NKV + h)*HD + d] — identical to the historical Vec push order, so
+// kv_root hashes the exact same byte sequence (prefix [..len*NKV*HD]).
+struct KvState { k16: &'static mut [i64], v16: &'static mut [i64], len: usize, bound: usize }
+
+struct Model {
+    g: Gguf, tb: Tables, layers: Vec<LayerW>,
+    dstates: Vec<DState>, kvstates: Vec<KvState>,
+    inv_sqrt128_q30: i128,
+    route_log: Vec<u8>,
+    onorm30: Vec<i128>,
+}
+
+impl Model {
+    fn new(g: Gguf, tb: Tables) -> Model {
+        let layers: Vec<LayerW> = (0..NL).map(|l| load_layer(&g, l)).collect();
+        let dstates = (0..NL).map(|_| DState { s: page_alloc_i64(HV * SDIM * SDIM), conv: page_alloc_i64(3 * 8192) }).collect();
+        // attention layers get kvmax rows pre-allocated (lazy anon pages: untouched rows cost nothing)
+        let kvmax = kvmax_env(tb.smax);
+        let kvstates = (0..NL).map(|l| if layers[l].is_attn {
+            KvState { k16: page_alloc_i64(kvmax * NKV * HD), v16: page_alloc_i64(kvmax * NKV * HD), len: 0, bound: 0 }
+        } else {
+            KvState { k16: &mut [], v16: &mut [], len: 0, bound: 0 }
+        }).collect();
+        let onorm30 = load_f32_vec(&g, "output_norm.weight", 30);
+        Model { g, tb, layers, dstates, kvstates, inv_sqrt128_q30: 94906266, route_log: Vec::new(), onorm30 } // RNE(2^30/sqrt(128))
+    }
+
+    fn deltanet(&mut self, l: usize, xq: &[i64], xs: i128, pos: usize) -> (Vec<i64>, i128) {
+        let _ = pos;
+        if unsafe { METAL_V3 } {
+            let shadow = std::env::var("QI35_SHADOW").is_ok();
+            let snap = if shadow { Some((self.dstates[l].s.to_vec(), self.dstates[l].conv.to_vec())) } else { None };
+            let gpu = self.deltanet_gpu(l, xq, xs);
+            if let Some((mut s0, mut c0)) = snap {
+                let cpu = self.deltanet_cpu_on(l, xq, xs, &mut s0, &mut c0);
+                let state_ok = self.dstates[l].s[..] == s0[..] && self.dstates[l].conv[..] == c0[..];
+                if gpu.1 != cpu.1 || gpu.0 != cpu.0 || !state_ok {
+                    self.dn_dump_mismatch(l, &gpu, &cpu, &s0, &c0);
+                    panic!("dn mismatch layer {} (scale_eq={} out_eq={} state_eq={})",
+                        l, gpu.1 == cpu.1, gpu.0 == cpu.0, state_ok);
+                }
+                eprintln!("SHADOW dn layer {} OK", l);
+            }
+            return gpu;
+        }
+        // CPU path operates on the (page-aligned, possibly GPU-shared) state in place
+        let (sp, sl) = (self.dstates[l].s.as_mut_ptr(), self.dstates[l].s.len());
+        let (cp, cl) = (self.dstates[l].conv.as_mut_ptr(), self.dstates[l].conv.len());
+        let (s, conv) = unsafe { (std::slice::from_raw_parts_mut(sp, sl), std::slice::from_raw_parts_mut(cp, cl)) };
+        self.deltanet_cpu_on(l, xq, xs, s, conv)
+    }
+
+    fn deltanet_gpu(&mut self, l: usize, xq: &[i64], xs: i128) -> (Vec<i64>, i128) {
+        let p = format!("blk.{}.", l);
+        let names = ["attn_qkv.weight", "attn_gate.weight", "ssm_beta.weight", "ssm_alpha.weight", "ssm_out.weight"];
+        let mut dt = DnTensors { ptr: [std::ptr::null(); 5], len: [0; 5], ty: [0; 5], layer: l as u32 };
+        for (i, n) in names.iter().enumerate() {
+            let t = self.g.t(&format!("{}{}", p, n));
+            assert!(t.ty == 12 || t.ty == 14, "dn gemm on type {}", t.ty); // same failure mode as the CPU path
+            let blocksz = if t.ty == 12 { 144 } else { 210 };
+            let total_rows: usize = t.ne[1..].iter().product();
+            dt.len[i] = (total_rows * (t.ne[0] / 256) * blocksz) as u64;
+            dt.ptr[i] = unsafe { self.g.data.as_ptr().add(self.g.base + t.off) };
+            dt.ty[i] = t.ty;
+        }
+        let xqi: Vec<i32> = xq.iter().map(|&v| v as i32).collect();
+        let xs16 = i128_to16(xs);
+        let mut mq = vec![0i32; D];
+        let mut ms16 = [0u8; 16];
+        let t0 = std::time::Instant::now();
+        let rc = unsafe { qi35_dn_run(&dt, xqi.as_ptr(), xs16.as_ptr(), mq.as_mut_ptr(), ms16.as_mut_ptr()) };
+        assert_eq!(rc, 0, "dn gpu failed");
+        GPU_DN_NS.fetch_add(t0.elapsed().as_nanos() as u64, std::sync::atomic::Ordering::Relaxed);
+        (mq.iter().map(|&v| v as i64).collect(), i128_from16(&ms16))
+    }
+
+    // stage-by-stage GPU-vs-CPU dump on shadow mismatch (mirrors the moe DBG30 flow that
+    // pinpointed the k_topk half-boundary bug mechanically)
+    fn dn_dump_mismatch(&self, l: usize, gpu: &(Vec<i64>, i128), cpu: &(Vec<i64>, i128), s0: &[i64], c0: &[i64]) {
+        let mut gconvs = vec![0i64; 8192];
+        let mut gqk = vec![0i64; 4096];
+        let mut go24 = vec![0i64; 4096];
+        let mut gy = vec![0u8; 4096 * 16];
+        let mut gyq = vec![0i32; 4096];
+        let mut regs = vec![0u8; 256 * 16];
+        unsafe { qi35_dn_debug(gconvs.as_mut_ptr(), gqk.as_mut_ptr(), go24.as_mut_ptr(), gy.as_mut_ptr(), gyq.as_mut_ptr(), regs.as_mut_ptr()); }
+        let reg = |slot: usize| i128_from16(&regs[slot * 16..slot * 16 + 16]);
+        eprintln!("DNDBG layer {} ms gpu={:x} cpu={:x}", l, gpu.1, cpu.1);
+        if let Some(st) = unsafe { (*std::ptr::addr_of_mut!(DN_STASH)).take() } {
+            eprintln!("DNDBG s_qkv cpu={:x} gpu={:x} | s_z cpu={:x} gpu={:x} | s_b cpu={:x} gpu={:x} | s_a cpu={:x} gpu={:x} | ys cpu={:x} gpu={:x}",
+                st.s_qkv, reg(1), st.s_z, reg(2), st.s_b, reg(3), st.s_a, reg(4), st.ys, reg(5));
+            for h in 0..HV {
+                if st.beta16[h] != reg(8 + h) || st.gam30[h] != reg(40 + h) {
+                    eprintln!("DNDBG scal h{} beta cpu={:x} gpu={:x} | gam cpu={:x} gpu={:x}", h, st.beta16[h], reg(8 + h), st.gam30[h], reg(40 + h));
+                }
+            }
+            let mut n = 0;
+            for c in 0..8192 { if st.convs[c] != gconvs[c] { if n < 4 { eprintln!("DNDBG convs[{}] cpu={} gpu={}", c, st.convs[c], gconvs[c]); } n += 1; } }
+            eprintln!("DNDBG convs_diffs={}", n);
+            n = 0;
+            for i in 0..4096 { if st.qk[i] != gqk[i] { if n < 4 { eprintln!("DNDBG qk[{}] cpu={} gpu={}", i, st.qk[i], gqk[i]); } n += 1; } }
+            eprintln!("DNDBG qk_diffs={}", n);
+            n = 0;
+            for i in 0..4096 { if st.o24[i] != go24[i] as i128 { if n < 4 { eprintln!("DNDBG o24[{}] cpu={} gpu={}", i, st.o24[i], go24[i]); } n += 1; } }
+            eprintln!("DNDBG o24_diffs={}", n);
+            n = 0;
+            for i in 0..4096 {
+                let gv = i128_from16(&gy[i * 16..i * 16 + 16]);
+                if st.y[i] != gv { if n < 4 { eprintln!("DNDBG y[{}] cpu={:x} gpu={:x}", i, st.y[i], gv); } n += 1; }
+            }
+            eprintln!("DNDBG y_diffs={}", n);
+            n = 0;
+            for i in 0..4096 { if st.yq[i] != gyq[i] as i64 { if n < 4 { eprintln!("DNDBG yq[{}] cpu={} gpu={}", i, st.yq[i], gyq[i]); } n += 1; } }
+            eprintln!("DNDBG yq_diffs={}", n);
+        }
+        let mut n = 0;
+        for i in 0..D { if gpu.0[i] != cpu.0[i] { if n < 4 { eprintln!("DNDBG mq[{}] gpu={} cpu={}", i, gpu.0[i], cpu.0[i]); } n += 1; } }
+        eprintln!("DNDBG mq_diffs={}", n);
+        n = 0;
+        for i in 0..s0.len() { if self.dstates[l].s[i] != s0[i] { if n < 4 { eprintln!("DNDBG S[{}] gpu={} cpu={}", i, self.dstates[l].s[i], s0[i]); } n += 1; } }
+        eprintln!("DNDBG state_diffs={}", n);
+        n = 0;
+        for i in 0..c0.len() { if self.dstates[l].conv[i] != c0[i] { if n < 4 { eprintln!("DNDBG ring[{}] gpu={} cpu={}", i, self.dstates[l].conv[i], c0[i]); } n += 1; } }
+        eprintln!("DNDBG ring_diffs={}", n);
+    }
+
+    fn deltanet_cpu_on(&mut self, l: usize, xq: &[i64], xs: i128, s_state: &mut [i64], conv: &mut [i64]) -> (Vec<i64>, i128) {
+        let shadow = unsafe { METAL_V3 } && std::env::var("QI35_SHADOW").is_ok();
+        let p = format!("blk.{}.", l);
+        let tb = &self.tb;
+        let qkv_name = format!("{}attn_qkv.weight", p);
+        let gate_name = format!("{}attn_gate.weight", p);
+        let mut br = gemm_batch(&self.g, &[(&qkv_name, 0, 8192, xq), (&gate_name, 0, 4096, xq)]);
+        let (z_q, z_s) = proj_finish(br.pop().unwrap(), xs);
+        let (qkv_q, qkv_s) = proj_finish(br.pop().unwrap(), xs);
+        let (b_q, b_s) = proj(&self.g, &format!("{}ssm_beta.weight", p), 0, HV, xq, xs);
+        let (a_q, a_s) = proj(&self.g, &format!("{}ssm_alpha.weight", p), 0, HV, xq, xs);
+        let lw = &self.layers[l];
+        // scalars
+        let mut beta16 = [0i128; HV]; let mut gam30 = [0i128; HV];
+        for h in 0..HV {
+            let b16 = to_fix(b_q[h] as i128, b_s, 16);
+            beta16[h] = tb.sig_at(b16) as i128;
+            let a16 = to_fix(a_q[h] as i128, a_s, 16) + lw.ssm_dt16[h];
+            let spl = tb.softplus_at(a16);
+            let gprod = lw.ssm_a30[h] * spl; // Q46, negative
+            let gidx = rne(-gprod, 35);      // 1/2048 units
+            gam30[h] = tb.gamma_at(gidx) as i128;
+        }
+        // conv ring: [3*8192] Q16 + current
+        let u: Vec<i64> = (0..8192).map(|c| to_fix(qkv_q[c] as i128, qkv_s, 16) as i64).collect();
+        let mut convs = vec![0i64; 8192];
+        for c in 0..8192 {
+            let w = &lw.convw30[c * 4..c * 4 + 4];
+            let acc: i128 = w[0] * conv[c] as i128 + w[1] * conv[8192 + c] as i128
+                + w[2] * conv[2 * 8192 + c] as i128 + w[3] * u[c] as i128;
+            let raw = rne(acc, 30);
+            convs[c] = tb.silu_q16(raw) as i64;
+        }
+        // shift ring
+        conv.copy_within(8192..3 * 8192, 0);
+        conv[2 * 8192..3 * 8192].copy_from_slice(&u);
+        // split + L2 norm (Q20 units)
+        let mut qU = [[0i64; SDIM]; HK]; let mut kU = [[0i64; SDIM]; HK];
+        for h in 0..HK {
+            for (dst, base) in [(&mut qU, 0usize), (&mut kU, 2048)] {
+                let seg = &convs[base + h * SDIM..base + h * SDIM + SDIM];
+                let n2: i128 = seg.iter().map(|&v| (v as i128) * (v as i128)).sum();
+                let n = isqrt(n2).max(1);
+                for d in 0..SDIM { dst[h][d] = fdiv((seg[d] as i128) * (1 << 21) + n, 2 * n) as i64; }
+            }
+        }
+        // recurrence per head, output Q24 — parallel over heads (integer => bit-stable)
+        let mut o24 = vec![0i128; HV * SDIM];
+        let inv30 = self.inv_sqrt128_q30;
+        {
+            let sbase = s_state.as_mut_ptr() as usize;
+            let obase = o24.as_mut_ptr() as usize;
+            let gam30 = &gam30; let beta16 = &beta16;
+            let ku_ref = &kU; let qu_ref = &qU; let convs_ref = &convs;
+            let per_head = move |h: usize| {
+                let s = unsafe { std::slice::from_raw_parts_mut((sbase as *mut i64).add(h * SDIM * SDIM), SDIM * SDIM) };
+                let oh = unsafe { std::slice::from_raw_parts_mut((obase as *mut i128).add(h * SDIM), SDIM) };
+                let kh = h % HK;
+                let g = gam30[h]; let b = beta16[h];
+                let kv = &ku_ref[kh]; let qv = &qu_ref[kh];
+                for x in s.iter_mut() { *x = ((*x as i128 * g + (1 << 29)) >> 30) as i64; }
+                let mut dlt = [0i128; SDIM];
+                for j in 0..SDIM {
+                    let mut sk: i128 = 0;
+                    for i in 0..SDIM { sk += s[i * SDIM + j] as i128 * kv[i] as i128; }
+                    let sk = (sk + (1 << 19)) >> 20;
+                    let v16 = convs_ref[4096 + h * SDIM + j] as i128;
+                    dlt[j] = (((v16 << 8) - sk) * b + (1 << 15)) >> 16;
+                }
+                for i in 0..SDIM {
+                    let ki = kv[i] as i128;
+                    for j in 0..SDIM { s[i * SDIM + j] += (((ki * dlt[j]) + (1 << 19)) >> 20) as i64; }
+                }
+                for j in 0..SDIM {
+                    let mut acc: i128 = 0;
+                    for i in 0..SDIM { acc += s[i * SDIM + j] as i128 * qv[i] as i128; }
+                    let raw = (acc + (1 << 19)) >> 20;
+                    oh[j] = (raw * inv30 + (1 << 29)) >> 30;
+                }
+            };
+            parallel_for(HV, &per_head);
+        }
+        // gated norm + silu(z) -> aq -> ssm_out proj
+        let mut y = vec![0i128; HV * SDIM];
+        for h in 0..HV {
+            let normed = rms_perhead_q24(&o24[h * SDIM..(h + 1) * SDIM], &lw.ssm_norm);
+            for j in 0..SDIM {
+                let z16 = to_fix(z_q[h * SDIM + j] as i128, z_s, 16);
+                y[h * SDIM + j] = normed[j] * tb.silu_q16(z16);
+            }
+        }
+        let (yq, ys0) = aq_row(&y, 1i128 << SC);
+        let ys = rne(ys0, 60);
+        if shadow {
+            let mut qkflat = vec![0i64; 4096];
+            for h in 0..HK {
+                for d in 0..SDIM { qkflat[h * SDIM + d] = qU[h][d]; qkflat[2048 + h * SDIM + d] = kU[h][d]; }
+            }
+            unsafe {
+                DN_STASH = Some(DnStash {
+                    convs: convs.clone(), qk: qkflat, o24: o24.clone(), y: y.clone(), yq: yq.clone(),
+                    s_qkv: qkv_s, s_z: z_s, s_b: b_s, s_a: a_s, ys,
+                    beta16: beta16.to_vec(), gam30: gam30.to_vec(),
+                });
+            }
+        }
+        proj(&self.g, &format!("{}ssm_out.weight", p), 0, D, &yq, ys)
+    }
+
+    fn attention(&mut self, l: usize, xq: &[i64], xs: i128, pos: usize) -> (Vec<i64>, i128) {
+        if unsafe { METAL_V3 } && !at_cpu() {
+            let shadow = std::env::var("QI35_SHADOW").is_ok();
+            assert_eq!(self.kvstates[l].len, pos, "kv len/pos desync layer {}", l);
+            let n = (pos + 1) * NKV * HD;
+            let snap = if shadow {
+                Some((self.kvstates[l].k16[..n].to_vec(), self.kvstates[l].v16[..n].to_vec()))
+            } else { None };
+            let gpu = self.attention_gpu(l, xq, xs, pos);
+            if let Some((mut kc, mut vc)) = snap {
+                let cpu = self.attention_cpu_on(l, xq, xs, pos, &mut kc, &mut vc);
+                let cache_ok = self.kvstates[l].k16[..n] == kc[..] && self.kvstates[l].v16[..n] == vc[..];
+                if gpu.1 != cpu.1 || gpu.0 != cpu.0 || !cache_ok {
+                    self.at_dump_mismatch(l, pos, &gpu, &cpu, &kc, &vc);
+                    panic!("at mismatch layer {} pos {} (scale_eq={} out_eq={} cache_eq={})",
+                        l, pos, gpu.1 == cpu.1, gpu.0 == cpu.0, cache_ok);
+                }
+                eprintln!("SHADOW at layer {} OK", l);
+            }
+            self.kvstates[l].len += 1;
+            return gpu;
+        }
+        // CPU path operates on the (page-aligned, possibly GPU-shared) cache in place
+        let (kp, kl) = (self.kvstates[l].k16.as_mut_ptr(), self.kvstates[l].k16.len());
+        let (vp, vl) = (self.kvstates[l].v16.as_mut_ptr(), self.kvstates[l].v16.len());
+        let (kc, vc) = unsafe { (std::slice::from_raw_parts_mut(kp, kl), std::slice::from_raw_parts_mut(vp, vl)) };
+        let r = self.attention_cpu_on(l, xq, xs, pos, kc, vc);
+        self.kvstates[l].len += 1;
+        r
+    }
+
+    fn attention_gpu(&mut self, l: usize, xq: &[i64], xs: i128, pos: usize) -> (Vec<i64>, i128) {
+        assert!(pos < self.tb.smax);
+        assert!((pos + 1) * NKV * HD <= self.kvstates[l].k16.len(), "kv prealloc exceeded (QI35_KVMAX)");
+        // grow the GPU binding x4 when the position outruns it (re-wraps the same pages; data intact)
+        if pos + 1 > self.kvstates[l].bound {
+            let cap = self.kvstates[l].k16.len() / (NKV * HD);
+            let nb = round4((self.kvstates[l].bound * 4).max(pos + 1)).min(cap);
+            let rc = unsafe {
+                qi35_at_bind_kv(l as u32,
+                    self.kvstates[l].k16.as_mut_ptr(), (nb * NKV * HD * 8) as u64,
+                    self.kvstates[l].v16.as_mut_ptr(), (nb * NKV * HD * 8) as u64)
+            };
+            assert_eq!(rc, 0, "at rebind_kv failed layer {}", l);
+            self.kvstates[l].bound = nb;
+        }
+        let p = format!("blk.{}.", l);
+        let names = ["attn_q.weight", "attn_k.weight", "attn_v.weight", "attn_output.weight"];
+        // geometry the kernels hardcode (rows / k -> nsb); fail like the CPU path would, not silently
+        let expect: [(usize, usize); 4] = [(D, 8192), (D, 512), (D, 512), (NH * HD, D)];
+        let mut at = AtTensors { ptr: [std::ptr::null(); 4], len: [0; 4], ty: [0; 4], layer: l as u32, pos: pos as u32 };
+        for (i, n) in names.iter().enumerate() {
+            let t = self.g.t(&format!("{}{}", p, n));
+            assert!(t.ty == 12 || t.ty == 14, "at gemm on type {}", t.ty);
+            let rows: usize = t.ne[1..].iter().product();
+            assert_eq!((t.ne[0], rows), expect[i], "at tensor geometry mismatch: {}", n);
+            let blocksz = if t.ty == 12 { 144 } else { 210 };
+            let total_rows: usize = t.ne[1..].iter().product();
+            at.len[i] = (total_rows * (t.ne[0] / 256) * blocksz) as u64;
+            at.ptr[i] = unsafe { self.g.data.as_ptr().add(self.g.base + t.off) };
+            at.ty[i] = t.ty;
+        }
+        let xqi: Vec<i32> = xq.iter().map(|&v| v as i32).collect();
+        let xs16 = i128_to16(xs);
+        let mut mq = vec![0i32; D];
+        let mut ms16 = [0u8; 16];
+        let t0 = std::time::Instant::now();
+        let rc = unsafe { qi35_at_run(&at, xqi.as_ptr(), xs16.as_ptr(), mq.as_mut_ptr(), ms16.as_mut_ptr()) };
+        assert_eq!(rc, 0, "at gpu failed");
+        GPU_AT_NS.fetch_add(t0.elapsed().as_nanos() as u64, std::sync::atomic::Ordering::Relaxed);
+        (mq.iter().map(|&v| v as i64).collect(), i128_from16(&ms16))
+    }
+
+    // stage-by-stage GPU-vs-CPU dump on shadow mismatch (mirrors the dn flow)
+    fn at_dump_mismatch(&self, l: usize, pos: usize, gpu: &(Vec<i64>, i128), cpu: &(Vec<i64>, i128), kc: &[i64], vc: &[i64]) {
+        let tlen = pos + 1;
+        let mut gqn = vec![0u8; 4096 * 16];
+        let mut gkn = vec![0u8; 512 * 16];
+        let mut gqnq = vec![0i32; 4096];
+        let mut gknq = vec![0i32; 512];
+        let mut gatt = vec![0u8; 4096 * 16];
+        let mut gatq = vec![0i32; 4096];
+        let mut regs = vec![0u8; 256 * 16];
+        let mut gscr = vec![0u8; NH * tlen * 16];
+        let mut ges = vec![0u8; NH * tlen * 16];
+        unsafe {
+            qi35_at_debug(gqn.as_mut_ptr(), gkn.as_mut_ptr(), gqnq.as_mut_ptr(), gknq.as_mut_ptr(),
+                          gatt.as_mut_ptr(), gatq.as_mut_ptr(), regs.as_mut_ptr(),
+                          gscr.as_mut_ptr(), ges.as_mut_ptr(), tlen as u64);
+        }
+        let reg = |slot: usize| i128_from16(&regs[slot * 16..slot * 16 + 16]);
+        eprintln!("ATDBG layer {} pos {} ms gpu={:x} cpu={:x}", l, pos, gpu.1, cpu.1);
+        if let Some(st) = unsafe { (*std::ptr::addr_of_mut!(AT_STASH)).take() } {
+            eprintln!("ATDBG s_qf cpu={:x} gpu={:x} | s_k cpu={:x} gpu={:x} | s_v cpu={:x} gpu={:x}",
+                st.s_qf, reg(1), st.s_k, reg(2), st.s_v, reg(3));
+            eprintln!("ATDBG qn_s cpu={:x} gpu={:x} | kn_s cpu={:x} gpu={:x} | at_s cpu={:x} gpu={:x} | cq cpu={:x} gpu={:x}",
+                st.qn_s, reg(5), st.kn_s, reg(6), st.at_s, reg(7), st.cq, reg(10));
+            let mut n = 0;
+            for i in 0..4096 {
+                let gv = i128_from16(&gqn[i * 16..i * 16 + 16]);
+                if st.qn[i] != gv { if n < 4 { eprintln!("ATDBG qn[{}] cpu={:x} gpu={:x}", i, st.qn[i], gv); } n += 1; }
+            }
+            eprintln!("ATDBG qn_diffs={}", n);
+            n = 0;
+            for i in 0..512 {
+                let gv = i128_from16(&gkn[i * 16..i * 16 + 16]);
+                if st.kn[i] != gv { if n < 4 { eprintln!("ATDBG kn[{}] cpu={:x} gpu={:x}", i, st.kn[i], gv); } n += 1; }
+            }
+            eprintln!("ATDBG kn_diffs={}", n);
+            n = 0;
+            for i in 0..4096 { if st.qr[i] != gqnq[i] as i64 { if n < 4 { eprintln!("ATDBG qr[{}] cpu={} gpu={}", i, st.qr[i], gqnq[i]); } n += 1; } }
+            eprintln!("ATDBG qr_diffs={}", n);
+            n = 0;
+            for i in 0..512 { if st.kr[i] != gknq[i] as i64 { if n < 4 { eprintln!("ATDBG kr[{}] cpu={} gpu={}", i, st.kr[i], gknq[i]); } n += 1; } }
+            eprintln!("ATDBG kr_diffs={}", n);
+            n = 0;
+            for i in 0..NH * tlen {
+                let gv = i128_from16(&gscr[i * 16..i * 16 + 16]);
+                if st.scr[i] != gv { if n < 4 { eprintln!("ATDBG scr[{}] cpu={:x} gpu={:x}", i, st.scr[i], gv); } n += 1; }
+            }
+            eprintln!("ATDBG scr_diffs={}", n);
+            n = 0;
+            for i in 0..NH * tlen {
+                let gv = i128_from16(&ges[i * 16..i * 16 + 16]);
+                if st.es[i] != gv { if n < 4 { eprintln!("ATDBG es[{}] cpu={:x} gpu={:x}", i, st.es[i], gv); } n += 1; }
+            }
+            eprintln!("ATDBG es_diffs={}", n);
+            n = 0;
+            for i in 0..4096 {
+                let gv = i128_from16(&gatt[i * 16..i * 16 + 16]);
+                if st.att[i] != gv { if n < 4 { eprintln!("ATDBG att[{}] cpu={:x} gpu={:x}", i, st.att[i], gv); } n += 1; }
+            }
+            eprintln!("ATDBG att_diffs={}", n);
+            n = 0;
+            for i in 0..4096 { if st.atq[i] != gatq[i] as i64 { if n < 4 { eprintln!("ATDBG atq[{}] cpu={} gpu={}", i, st.atq[i], gatq[i]); } n += 1; } }
+            eprintln!("ATDBG atq_diffs={}", n);
+        }
+        let mut n = 0;
+        for i in 0..D { if gpu.0[i] != cpu.0[i] { if n < 4 { eprintln!("ATDBG mq[{}] gpu={} cpu={}", i, gpu.0[i], cpu.0[i]); } n += 1; } }
+        eprintln!("ATDBG mq_diffs={}", n);
+        let nk = (pos + 1) * NKV * HD;
+        n = 0;
+        for i in 0..nk { if self.kvstates[l].k16[i] != kc[i] { if n < 4 { eprintln!("ATDBG k16[{}] gpu={} cpu={}", i, self.kvstates[l].k16[i], kc[i]); } n += 1; } }
+        eprintln!("ATDBG k16_diffs={}", n);
+        n = 0;
+        for i in 0..nk { if self.kvstates[l].v16[i] != vc[i] { if n < 4 { eprintln!("ATDBG v16[{}] gpu={} cpu={}", i, self.kvstates[l].v16[i], vc[i]); } n += 1; } }
+        eprintln!("ATDBG v16_diffs={}", n);
+    }
+
+    fn attention_cpu_on(&mut self, l: usize, xq: &[i64], xs: i128, pos: usize,
+                        kcache: &mut [i64], vcache: &mut [i64]) -> (Vec<i64>, i128) {
+        let shadow = unsafe { METAL_V3 } && std::env::var("QI35_SHADOW").is_ok();
+        let p = format!("blk.{}.", l);
+        let qn_name = format!("{}attn_q.weight", p);
+        let kn_name = format!("{}attn_k.weight", p);
+        let vn_name = format!("{}attn_v.weight", p);
+        let mut br = gemm_batch(&self.g, &[(&qn_name, 0, 8192, xq), (&kn_name, 0, 512, xq), (&vn_name, 0, 512, xq)]);
+        let (v_q, v_s) = proj_finish(br.pop().unwrap(), xs);
+        let (k_q, k_s) = proj_finish(br.pop().unwrap(), xs);
+        let (qf_q, qf_s) = proj_finish(br.pop().unwrap(), xs);
+        let lw = &self.layers[l];
+        // per-head q/k norm -> aq
+        let mut qn = vec![0i128; NH * HD]; let mut kn = vec![0i128; NKV * HD];
+        for h in 0..NH {
+            let seg: Vec<i64> = (0..HD).map(|d| qf_q[512 * h + d]).collect();
+            let nm = rms_perhead_a24(&seg, qf_s, &lw.qnorm);
+            qn[h * HD..(h + 1) * HD].copy_from_slice(&nm);
+        }
+        for h in 0..NKV {
+            let seg: Vec<i64> = (0..HD).map(|d| k_q[256 * h + d]).collect();
+            let nm = rms_perhead_a24(&seg, k_s, &lw.knorm);
+            kn[h * HD..(h + 1) * HD].copy_from_slice(&nm);
+        }
+        let (qn_q, qn_s0) = aq_row(&qn, 1i128 << SC); let qn_s = rne(qn_s0, 44);
+        let (kn_q, kn_s0) = aq_row(&kn, 1i128 << SC); let kn_s = rne(kn_s0, 44);
+        // rope (Q30 tables)
+        let tb = &self.tb;
+        assert!(pos < tb.smax);
+        let mut qr = qn_q.clone(); let mut kr = kn_q.clone();
+        for (arr, nh) in [(&mut qr, NH), (&mut kr, NKV)] {
+            for h in 0..nh {
+                for i in 0..NROT / 2 {
+                    let x0 = arr[h * HD + i] as i128; let x1 = arr[h * HD + i + 32] as i128;
+                    let c = tb.cos[pos * 32 + i] as i128; let sn = tb.sin[pos * 32 + i] as i128;
+                    arr[h * HD + i] = rne(x0 * c - x1 * sn, 30) as i64;
+                    arr[h * HD + i + 32] = rne(x0 * sn + x1 * c, 30) as i64;
+                }
+            }
+        }
+        // KV append (absolute Q16) at row pos — same layout as the historical Vec push order
+        for h in 0..NKV {
+            for d in 0..HD {
+                kcache[(pos * NKV + h) * HD + d] = to_fix(kr[h * HD + d] as i128, kn_s, 16) as i64;
+                vcache[(pos * NKV + h) * HD + d] = to_fix(v_q[256 * h + d] as i128, v_s, 16) as i64;
+            }
+        }
+        // attention
+        let tlen = pos + 1;
+        let cq = rne(qn_s * 128, 16); // exp idx unit
+        let mut att = vec![0i128; NH * HD];
+        let mut stash_scr = if shadow { Vec::with_capacity(NH * tlen) } else { Vec::new() };
+        let mut stash_es = if shadow { Vec::with_capacity(NH * tlen) } else { Vec::new() };
+        for h in 0..NH {
+            let kvh = h / (NH / NKV);
+            let mut scr = vec![0i128; tlen];
+            for t in 0..tlen {
+                let krow = &kcache[(t * NKV + kvh) * HD..(t * NKV + kvh) * HD + HD];
+                let mut a: i128 = 0;
+                for d in 0..HD { a += qr[h * HD + d] as i128 * krow[d] as i128; }
+                scr[t] = a;
+            }
+            let m = *scr.iter().max().unwrap();
+            let mut es = vec![0i128; tlen]; let mut den: i128 = 0;
+            for t in 0..tlen {
+                let idx = apply(m - scr[t], cq);
+                es[t] = tb.expn_at(idx) as i128; den += es[t];
+            }
+            if den == 0 { den = 1; }
+            for d in 0..HD {
+                let mut acc: i128 = 0;
+                for t in 0..tlen { acc += es[t] * vcache[(t * NKV + kvh) * HD + d] as i128; }
+                let av = fdiv(acc * (1i128 << SC) + (den >> 1), den) >> SC; // Q16
+                let g16 = to_fix(qf_q[512 * h + 256 + d] as i128, qf_s, 16);
+                att[h * HD + d] = av * tb.sig_at(g16) as i128; // Q32
+            }
+            if shadow { stash_scr.extend_from_slice(&scr); stash_es.extend_from_slice(&es); }
+        }
+        let (at_q, at_s0) = aq_row(&att, 1i128 << SC);
+        let at_s = rne(at_s0, 32);
+        if shadow {
+            unsafe {
+                AT_STASH = Some(AtStash {
+                    qn: qn.clone(), kn: kn.clone(), qr: qr.clone(), kr: kr.clone(),
+                    att: att.clone(), atq: at_q.clone(), scr: stash_scr, es: stash_es,
+                    s_qf: qf_s, s_k: k_s, s_v: v_s, qn_s, kn_s, at_s, cq,
+                });
+            }
+        }
+        proj(&self.g, &format!("{}attn_output.weight", p), 0, D, &at_q, at_s)
+    }
+
+    fn moe(&mut self, l: usize, xq: &[i64], xs: i128) -> (Vec<i64>, i128) {
+        if unsafe { METAL_V3 } {
+            let gpu = self.moe_gpu(l, xq, xs);
+            if std::env::var("QI35_SHADOW").is_ok() {
+                let cpu = self.moe_cpu(l, xq, xs, false);
+                if gpu.1 != cpu.1 || gpu.0 != cpu.0 {
+                    // CPU-side router+topk reproduction for sel comparison
+                    let router = &self.layers[l].router30;
+                    let mut lg = vec![0i128; NEXP];
+                    for e in 0..NEXP {
+                        let base = e * D;
+                        let mut acc: i128 = 0;
+                        for i in 0..D { acc += (router[base + i] as i128) * xq[i] as i128; }
+                        lg[e] = acc;
+                    }
+                    let u = mul(xs, 1i128 << 30);
+                    let m = *lg.iter().max().unwrap();
+                    let c2048 = u * 2048;
+                    eprintln!("DBG30 u={:x} c2048={:x} fits_u64={}", u, c2048, c2048 >= 0 && c2048 <= u64::MAX as i128);
+                    let es: Vec<i128> = lg.iter().map(|&v| self.tb.expn_at(apply(m - v, c2048)) as i128).collect();
+                    let mut idxs: Vec<usize> = (0..NEXP).collect();
+                    idxs.sort_by(|&a, &b| es[b].cmp(&es[a]).then(a.cmp(&b)));
+                    let cpu_sel: Vec<usize> = idxs[0..TOPK].to_vec();
+                    let gpu_sel: Vec<u16> = self.route_log[self.route_log.len()-16..].chunks(2)
+                        .map(|c| u16::from_le_bytes([c[0], c[1]])).collect();
+                    eprintln!("DBG30 cpu_sel={:?} gpu_sel={:?}", cpu_sel, gpu_sel);
+                    let mut shown = 0;
+                    for i in 0..D {
+                        if gpu.0[i] != cpu.0[i] && shown < 6 {
+                            eprintln!("DBG30 q[{}] gpu={} cpu={}", i, gpu.0[i], cpu.0[i]);
+                            shown += 1;
+                        }
+                    }
+                    // stage-by-stage: GPU buffers vs CPU stash
+                    let mut gtot = vec![0i64; D];
+                    let mut gqdn = vec![0i32; 9 * D];
+                    let mut regs = vec![0u8; 256 * 16];
+                    unsafe { qi35_moe_debug(gtot.as_mut_ptr(), gqdn.as_mut_ptr(), regs.as_mut_ptr()); }
+                    let reg = |slot: usize| i128_from16(&regs[slot * 16..slot * 16 + 16]);
+                    if let Some((dqall, accs, smax, smax2, out)) = unsafe { DBG_STASH.take() } {
+                        let mut dq_diffs = 0;
+                        for e in 0..9 {
+                            for i in 0..D {
+                                if dqall[e * D + i] != gqdn[e * D + i] as i64 {
+                                    if dq_diffs < 3 { eprintln!("DBG30 dq[{}][{}] gpu={} cpu={}", e, i, gqdn[e * D + i], dqall[e * D + i]); }
+                                    dq_diffs += 1;
+                                }
+                            }
+                        }
+                        eprintln!("DBG30 dq_diffs={}", dq_diffs);
+                        eprintln!("DBG30 smax cpu={:x} gpu_reg151={:x}", smax, reg(151));
+                        eprintln!("DBG30 smax2 cpu={:x} gpu_reg150={:x}", smax2, reg(150));
+                        for e in 0..8 {
+                            let cr = (accs[e] << SC) / smax;
+                            let gr = reg(160 + 16 + e);
+                            if cr != gr { eprintln!("DBG30 rat1[{}] cpu={:x} gpu={:x} accs={:x} gpu_accs={:x}", e, cr, gr, accs[e], reg(140 + e)); }
+                        }
+                        let cr1 = (smax << SC) / smax2; let cr2 = (accs[8] << SC) / smax2;
+                        if cr1 != reg(184) { eprintln!("DBG30 r1 cpu={:x} gpu={:x}", cr1, reg(184)); }
+                        if cr2 != reg(185) { eprintln!("DBG30 r2 cpu={:x} gpu={:x} shs cpu={:x} gpu={:x}", cr2, reg(185), accs[8], reg(148)); }
+                        let mut tot_diffs = 0;
+                        for i in 0..D {
+                            if out[i] != gtot[i] as i128 {
+                                if tot_diffs < 4 { eprintln!("DBG30 tot[{}] gpu={} cpu={}", i, gtot[i], out[i]); }
+                                tot_diffs += 1;
+                            }
+                        }
+                        eprintln!("DBG30 tot_diffs={}", tot_diffs);
+                        let mut gwn = vec![0i64; 8];
+                        unsafe { qi35_moe_debug_wn(gwn.as_mut_ptr()); }
+                        for e in 0..8 {
+                            let cds = unsafe { DBG_DS[e] };
+                            let gds = reg(130 + e);
+                            let cwn = unsafe { DBG_WN[e] };
+                            if cds != gds || cwn != gwn[e] as i128 {
+                                eprintln!("DBG30 e{} ds cpu={:x} gpu={:x} | wn cpu={:x} gpu={:x} | amax_gpu={:x} cmax_gpu={:x} curhm_gpu={:x}",
+                                    e, cds, gds, cwn, gwn[e], reg(120 + e), reg(110 + e), reg(80 + e));
+                            }
+                        }
+                    }
+                    panic!("moe mismatch layer {} (scale_eq={})", l, gpu.1 == cpu.1);
+                }
+                eprintln!("SHADOW moe layer {} OK", l);
+            }
+            return gpu;
+        }
+        self.moe_cpu(l, xq, xs, true)
+    }
+
+    fn moe_gpu(&mut self, l: usize, xq: &[i64], xs: i128) -> (Vec<i64>, i128) {
+        let p = format!("blk.{}.", l);
+        let names = ["ffn_gate_exps.weight", "ffn_up_exps.weight", "ffn_down_exps.weight",
+                     "ffn_gate_shexp.weight", "ffn_up_shexp.weight", "ffn_down_shexp.weight"];
+        let mut ptrs = [std::ptr::null::<u8>(); 6];
+        let mut lens = [0u64; 6];
+        for (i, n) in names.iter().enumerate() {
+            let t = self.g.t(&format!("{}{}", p, n));
+            let blocksz = if t.ty == 12 { 144 } else { 210 };
+            let total_rows: usize = t.ne[1..].iter().product();
+            lens[i] = (total_rows * (t.ne[0] / 256) * blocksz) as u64;
+            ptrs[i] = unsafe { self.g.data.as_ptr().add(self.g.base + t.off) };
+        }
+        let mt = MoeTensors {
+            gate_ptr: ptrs[0], gate_len: lens[0], gate_off_unused: 0,
+            up_ptr: ptrs[1], up_len: lens[1],
+            down_ptr: ptrs[2], down_len: lens[2],
+            gsh_ptr: ptrs[3], gsh_len: lens[3],
+            ush_ptr: ptrs[4], ush_len: lens[4],
+            dsh_ptr: ptrs[5], dsh_len: lens[5],
+            layer: l as u32,
+        };
+        let xqi: Vec<i32> = xq.iter().map(|&v| v as i32).collect();
+        let xs16 = i128_to16(xs);
+        let mut sel = [0u32; 8];
+        let mut mq = vec![0i32; D];
+        let mut ms16 = [0u8; 16];
+        let t0 = std::time::Instant::now();
+        let rc = unsafe { qi35_moe_run(&mt, xqi.as_ptr(), xs16.as_ptr(), sel.as_mut_ptr(), mq.as_mut_ptr(), ms16.as_mut_ptr()) };
+        assert_eq!(rc, 0, "moe gpu failed");
+        GPU_XCONV_NS.fetch_add(t0.elapsed().as_nanos() as u64, std::sync::atomic::Ordering::Relaxed);
+        self.route_log.push(l as u8);
+        for &e in &sel { self.route_log.extend_from_slice(&(e as u16).to_le_bytes()); }
+        (mq.iter().map(|&v| v as i64).collect(), i128_from16(&ms16))
+    }
+
+    fn moe_cpu(&mut self, l: usize, xq: &[i64], xs: i128, log_route: bool) -> (Vec<i64>, i128) {
+        let p = format!("blk.{}.", l);
+        let tb = &self.tb;
+        // router (cached Q30 weights, parallel over experts)
+        let router = &self.layers[l].router30;
+        let mut lg = vec![0i128; NEXP];
+        par_chunks(&mut lg, |e, slot| {
+            let base = e * D;
+            let mut acc: i128 = 0;
+            for i in 0..D { acc += (router[base + i] as i128) * xq[i] as i128; }
+            *slot = acc;
+        });
+        let u = mul(xs, 1i128 << 30);
+        let m = *lg.iter().max().unwrap();
+        let c2048 = u * 2048;
+        let es: Vec<i128> = lg.iter().map(|&v| tb.expn_at(apply(m - v, c2048)) as i128).collect();
+        let den: i128 = es.iter().sum::<i128>().max(1);
+        let _ = den;
+        // top-8 desc, tie -> low index
+        let mut idxs: Vec<usize> = (0..NEXP).collect();
+        idxs.sort_by(|&a, &b| es[b].cmp(&es[a]).then(a.cmp(&b)));
+        let sel = &idxs[0..TOPK];
+        let dsel: i128 = sel.iter().map(|&e| es[e]).sum::<i128>().max(1);
+        let wn30: Vec<i128> = sel.iter().map(|&e| fdiv(es[e] * (1 << 30) + (dsel >> 1), dsel)).collect();
+        // experts — phase 1: all gate/up GEMMs (+ shared) in ONE commit
+        let gexp_name = format!("{}ffn_gate_exps.weight", p);
+        let uexp_name = format!("{}ffn_up_exps.weight", p);
+        let gsh_name = format!("{}ffn_gate_shexp.weight", p);
+        let ush_name = format!("{}ffn_up_shexp.weight", p);
+        let mut items1: Vec<(&str, usize, usize, &[i64])> = Vec::with_capacity(2 * TOPK + 2);
+        for &e in sel {
+            items1.push((&gexp_name, e * FEXP, FEXP, xq));
+            items1.push((&uexp_name, e * FEXP, FEXP, xq));
+        }
+        items1.push((&gsh_name, 0, FEXP, xq));
+        items1.push((&ush_name, 0, FEXP, xq));
+        let mut r1 = gemm_batch(&self.g, &items1);
+        let ush_res = r1.pop().unwrap();
+        let gsh_res = r1.pop().unwrap();
+        // glue per expert, then phase 2: all down GEMMs (+ shared) in ONE commit
+        let mut hqs: Vec<Vec<i64>> = Vec::with_capacity(TOPK);
+        let mut hss: Vec<i128> = Vec::with_capacity(TOPK);
+        for ei in 0..TOPK {
+            let (uq, us) = proj_finish(r1.remove(2 * (TOPK - 1 - ei) + 1), xs);
+            let (gq, gs) = proj_finish(r1.remove(2 * (TOPK - 1 - ei)), xs);
+            let _ = ei;
+            let hm: Vec<i128> = (0..FEXP).map(|i| {
+                let g16 = to_fix(gq[i] as i128, gs, 16);
+                tb.silu_q16(g16) * uq[i] as i128
+            }).collect();
+            let (hq2, hs0) = aq_row(&hm, mul(us, 1i128 << 44));
+            hqs.push(hq2); hss.push(hs0);
+        }
+        hqs.reverse(); hss.reverse();
+        let dexp_name = format!("{}ffn_down_exps.weight", p);
+        let dsh_name = format!("{}ffn_down_shexp.weight", p);
+        let mut items2: Vec<(&str, usize, usize, &[i64])> = Vec::with_capacity(TOPK + 1);
+        for (ei, &e) in sel.iter().enumerate() {
+            items2.push((&dexp_name, e * D, D, &hqs[ei]));
+        }
+        let mut acc_q: Vec<Vec<i64>> = Vec::with_capacity(TOPK);
+        let mut acc_s: Vec<i128> = Vec::with_capacity(TOPK);
+        {
+            let mut r2 = gemm_batch(&self.g, &items2);
+            unsafe { DBG_DS.clear(); }
+            for ei in (0..TOPK).rev() {
+                let (dq, ds) = proj_finish(r2.pop().unwrap(), hss[ei]);
+                unsafe { DBG_DS.push(ds); }
+                acc_q.push(dq); acc_s.push(mul(ds, wn30[ei] << 30));
+            }
+            unsafe { DBG_DS.reverse(); DBG_WN = wn30.clone(); }
+            acc_q.reverse(); acc_s.reverse();
+        }
+        let _ = &dsh_name;
+        let smax = *acc_s.iter().max().unwrap().max(&1);
+        let mut tot = vec![0i128; D];
+        for ei in 0..TOPK {
+            let r = (acc_s[ei] << SC) / smax;
+            for i in 0..D { tot[i] += apply(acc_q[ei][i] as i128, r); }
+        }
+        let stash_dq: Vec<i64> = acc_q.iter().flat_map(|v| v.iter().copied()).collect();
+        // shared expert (gate/up already computed in phase 1)
+        let (gq, gs) = proj_finish(gsh_res, xs);
+        let (uq, us) = proj_finish(ush_res, xs);
+        let hm: Vec<i128> = (0..FEXP).map(|i| {
+            let g16 = to_fix(gq[i] as i128, gs, 16);
+            tb.silu_q16(g16) * uq[i] as i128
+        }).collect();
+        let (hq2, hs0) = aq_row(&hm, mul(us, 1i128 << 44));
+        let (dq, ds) = proj(&self.g, &dsh_name, 0, D, &hq2, hs0);
+        let sw = &self.layers[l].shexp30;
+        let shl: i128 = (0..D).map(|i| (sw[i] as i128) * xq[i] as i128).sum();
+        let sh16 = to_fix(shl, mul(xs, 1i128 << 30), 16);
+        let sg = tb.sig_at(sh16) as i128;
+        let shs = mul(ds, sg << 44);
+        let smax2 = smax.max(shs).max(1);
+        let r1 = (smax << SC) / smax2; let r2 = (shs << SC) / smax2;
+        let out: Vec<i128> = (0..D).map(|i| apply(tot[i], r1) + apply(dq[i] as i128, r2)).collect();
+        if std::env::var("QI35_SHADOW").is_ok() {
+            let mut dqall = stash_dq.clone();
+            dqall.extend(dq.iter().copied());
+            let mut accs = acc_s.clone();
+            accs.push(shs);
+            unsafe { DBG_STASH = Some((dqall, accs, smax, smax2, out.clone())); }
+        }
+        let (q, s) = aq_row(&out, smax2);
+        // record the ranked expert route (consensus material for the v3 projection)
+        if log_route {
+            self.route_log.push(l as u8);
+            for &e in sel { self.route_log.extend_from_slice(&(e as u16).to_le_bytes()); }
+        }
+        (q, s)
+    }
+
+    // one full forward for one token at position pos; hv = residual (ints) with scale hs
+    fn forward_token(&mut self, tok: usize, pos: usize) -> Vec<(i128, i32)> {
+        self.forward_token_opt(tok, pos, true)
+    }
+    fn forward_token_opt(&mut self, tok: usize, pos: usize, need_logits: bool) -> Vec<(i128, i32)> {
+        let dbg = pos == 0 && std::env::var("QI35_DEBUG").is_ok();
+        let (mut hv, mut hs) = embed_row(&self.g, tok);
+        if dbg { eprintln!("DBG emb: {:?}", (0..6).map(|i| hv[i] as f64 * (hs as f64 / 2f64.powi(60))).collect::<Vec<_>>()); }
+        for l in 0..NL {
+            let lw_is_attn = self.layers[l].is_attn;
+            let (xn_q, xn_s) = rms_q(&self.g, &hv, hs, &self.layers[l].attn_norm);
+            if dbg && l == 0 { eprintln!("DBG xn0: {:?}", (0..6).map(|i| xn_q[i] as f64 * (xn_s as f64 / 2f64.powi(60))).collect::<Vec<_>>()); }
+            let (d_q, d_s) = if lw_is_attn {
+                self.attention(l, &xn_q, xn_s, pos)
+            } else {
+                self.deltanet(l, &xn_q, xn_s, pos)
+            };
+            if dbg && l == 0 { eprintln!("DBG dattn0: {:?}", (0..6).map(|i| d_q[i] as f64 * (d_s as f64 / 2f64.powi(60))).collect::<Vec<_>>()); }
+            let r = (d_s << SC) / hs;
+            for i in 0..D { hv[i] += apply(d_q[i] as i128, r); }
+            if dbg && l == 0 { eprintln!("DBG res0: {:?}", (0..6).map(|i| hv[i] as f64 * (hs as f64 / 2f64.powi(60))).collect::<Vec<_>>()); }
+            let (x2_q, x2_s) = rms_q(&self.g, &hv, hs, &self.layers[l].post_norm);
+            let (m_q, m_s) = self.moe(l, &x2_q, x2_s);
+            let r2 = (m_s << SC) / hs;
+            for i in 0..D { hv[i] += apply(m_q[i] as i128, r2); }
+            if std::env::var("QI35_HVDBG").is_ok() && pos == 0 {
+                let bytes: Vec<u8> = hv.iter().flat_map(|v| (*v as i128).to_le_bytes()).collect();
+                eprintln!("HVDBG layer {} hv_fnv {:016x} ms {:032x}", l, fnv(&bytes), m_s);
+            }
+            if dbg && (l == 0 || l == 3 || l == 39) { eprintln!("DBG lout{}: {:?}", l, (0..6).map(|i| hv[i] as f64 * (hs as f64 / 2f64.powi(60))).collect::<Vec<_>>()); }
+        }
+        if !need_logits { return Vec::new(); }
+        // final norm + LM head (Q6_K [2048, 248320])
+        let (xn_q, _xn_s) = rms_q(&self.g, &hv, hs, &self.onorm30);
+        let _ = &mut hs;
+        gemm_rows(&self.g, "output.weight", 0, VOCAB, &xn_q)
+    }
+
+    // reset per-conversation state (KV cache + DeltaNet state + conv ring)
+    fn reset(&mut self) {
+        for st in &mut self.dstates {
+            for x in st.s.iter_mut() { *x = 0; }
+            for x in st.conv.iter_mut() { *x = 0; }
+        }
+        for kv in &mut self.kvstates {
+            kv.len = 0; // rows are overwritten per position; roots/shadow read only the len prefix
+        }
+        self.route_log.clear();
+    }
+
+    // bit-exact execution roots: blake2b256 over route log / KV cache ints / DeltaNet states.
+    // Cross-backend equal by integer determinism (the whole point of the canonical class).
+    fn execution_roots(&self) -> ([u8; 32], [u8; 32], [u8; 32]) {
+        let routes = blake2b256(&self.route_log);
+        let mut kvh = Blake2b::new(32, &[]);
+        for kv in &self.kvstates {
+            let n = kv.len * NKV * HD;
+            for &x in &kv.k16[..n] { kvh.update(&x.to_le_bytes()); }
+            for &x in &kv.v16[..n] { kvh.update(&x.to_le_bytes()); }
+        }
+        let kvv = kvh.finalize(); let mut kv32 = [0u8; 32]; kv32.copy_from_slice(&kvv);
+        let mut sh = Blake2b::new(32, &[]);
+        for st in &self.dstates {
+            for &x in st.s.iter() { sh.update(&x.to_le_bytes()); }
+            for &x in st.conv.iter() { sh.update(&x.to_le_bytes()); }
+        }
+        let sv = sh.finalize(); let mut s32 = [0u8; 32]; s32.copy_from_slice(&sv);
+        (routes, kv32, s32)
+    }
+
+    // greedy decode from a full prompt (stateless between calls; caller resets first).
+    // returns generated token ids; stops at eos (if Some) or after max_new tokens.
+    fn generate(&mut self, prompt: &[usize], max_new: usize, eos: Option<usize>, verbose: bool) -> Vec<usize> {
+        let mut logits: Vec<(i128, i32)> = Vec::new();
+        for (pos, &tk) in prompt.iter().enumerate() {
+            let t = std::time::Instant::now();
+            logits = self.forward_token_opt(tk, pos, pos + 1 == prompt.len());
+            if verbose { eprintln!("  prefill {}/{} ({:.2}s)", pos + 1, prompt.len(), t.elapsed().as_secs_f64()); }
+        }
+        let mut gen = Vec::new();
+        for step in 0..max_new {
+            let best = argmax_logits(&logits);
+            if Some(best) == eos { break; }
+            gen.push(best);
+            let pos = prompt.len() + step;
+            let t = std::time::Instant::now();
+            logits = self.forward_token(best, pos);
+            if verbose { eprintln!("  decode {} -> {} ({:.2}s)", step, best, t.elapsed().as_secs_f64()); }
+        }
+        gen
+    }
+}
+
+fn argmax_logits(logits: &[(i128, i32)]) -> usize {
+    fn cmp_val(a1: i128, e1: i32, a2: i128, e2: i32) -> std::cmp::Ordering {
+        use std::cmp::Ordering::*;
+        let s1 = a1.signum(); let s2 = a2.signum();
+        if s1 != s2 { return s1.cmp(&s2); }
+        if s1 == 0 { return Equal; }
+        let m1 = a1.unsigned_abs(); let m2 = a2.unsigned_abs();
+        let b1 = 128 - m1.leading_zeros() as i64 + e1 as i64;
+        let b2 = 128 - m2.leading_zeros() as i64 + e2 as i64;
+        let ord = if b1 != b2 { b1.cmp(&b2) } else if e1 >= e2 {
+            (m1 << ((e1 - e2) as u32)).cmp(&m2)
+        } else {
+            m1.cmp(&(m2 << ((e2 - e1) as u32)))
+        };
+        if s1 > 0 { ord } else { ord.reverse() }
+    }
+    let mut best = 0usize;
+    for v in 1..logits.len() {
+        if cmp_val(logits[v].0, logits[v].1, logits[best].0, logits[best].1) == std::cmp::Ordering::Greater {
+            best = v;
+        }
+    }
+    best
+}
+
+// embedding: exact Q4_K row -> (ints, Q60 scale of 2^emin)
+fn embed_row(g: &Gguf, tok: usize) -> (Vec<i128>, i128) {
+    let t = g.t("token_embd.weight");
+    assert_eq!(t.ty, 12);
+    let k = t.ne[0]; let nsb = k / 256;
+    let raw = g.bytes("token_embd.weight", tok * nsb * 144, nsb * 144);
+    let mut emin = i32::MAX;
+    let mut parts: Vec<(i64, i32)> = Vec::with_capacity(k); // value = m * 2^e per element? keep per-element (m,e)
+    for b in 0..nsb {
+        let blk = &raw[b * 144..(b + 1) * 144];
+        let (dm, de) = f16_me(u16::from_le_bytes(blk[0..2].try_into().unwrap()));
+        let (mm, me) = f16_me(u16::from_le_bytes(blk[2..4].try_into().unwrap()));
+        let scl = &blk[4..16]; let qs = &blk[16..144];
+        if dm != 0 && de < emin { emin = de; }
+        if mm != 0 && me < emin { emin = me; }
+        let _ = (scl, qs);
+        parts.push((0, 0)); // placeholder; second pass below
+    }
+    if emin == i32::MAX { emin = 0; }
+    let mut vals = vec![0i128; k];
+    for b in 0..nsb {
+        let blk = &raw[b * 144..(b + 1) * 144];
+        let (dm, de) = f16_me(u16::from_le_bytes(blk[0..2].try_into().unwrap()));
+        let (mm, me) = f16_me(u16::from_le_bytes(blk[2..4].try_into().unwrap()));
+        let scl = &blk[4..16]; let qs = &blk[16..144];
+        for j in 0..8 {
+            let (sc, mn) = if j < 4 {
+                ((scl[j] & 63) as i64, (scl[j + 4] & 63) as i64)
+            } else {
+                ((((scl[j + 4] & 0xF) | ((scl[j - 4] >> 6) << 4))) as i64,
+                 (((scl[j + 4] >> 4) | ((scl[j] >> 6) << 4))) as i64)
+            };
+            let c = j / 2; let half = j % 2;
+            let qb = &qs[32 * c..32 * c + 32];
+            let off = b * 256 + 64 * c + 32 * half;
+            for l in 0..32 {
+                let qv = if half == 0 { (qb[l] & 0xF) as i64 } else { (qb[l] >> 4) as i64 };
+                let dpart = (dm * sc * qv) as i128;
+                let mpart = (mm * mn) as i128;
+                vals[off + l] = (dpart << (de - emin)) - (mpart << (me - emin));
+            }
+        }
+    }
+    // A24 quantize the row (per-token) like the reference
+    if std::env::var("QI35_DEBUG").is_ok() {
+        let (mi, mv) = vals.iter().enumerate().max_by_key(|(_, v)| v.abs()).map(|(i, v)| (i, *v)).unwrap();
+        eprintln!("DBG embrow: emin={} amax_idx={} amax_val={} real={}", emin, mi, mv, mv as f64 * 2f64.powi(emin));
+    }
+    let (q, s) = aq_row(&vals, q60(1, emin));
+    (q.iter().map(|&x| x as i128).collect(), s)
+}
+
+fn fnv(bytes: &[u8]) -> u64 {
+    let mut h = 0xcbf29ce484222325u64;
+    for &b in bytes { h ^= b as u64; h = h.wrapping_mul(0x100000001b3); }
+    h
+}
+
+// ---------- BLAKE2b (RFC 7693), pure Rust, keyed + unkeyed ----------
+const BLAKE2B_IV: [u64; 8] = [
+    0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
+    0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179,
+];
+const BLAKE2B_SIGMA: [[usize; 16]; 12] = [
+    [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],
+    [14,10,4,8,9,15,13,6,1,12,0,2,11,7,5,3],
+    [11,8,12,0,5,2,15,13,10,14,3,6,7,1,9,4],
+    [7,9,3,1,13,12,11,14,2,6,5,10,4,0,15,8],
+    [9,0,5,7,2,4,10,15,14,1,11,12,6,8,3,13],
+    [2,12,6,10,0,11,8,3,4,13,7,5,15,14,1,9],
+    [12,5,1,15,14,13,4,10,0,7,6,3,9,2,8,11],
+    [13,11,7,14,12,1,3,9,5,0,15,4,8,6,2,10],
+    [6,15,14,9,11,3,0,8,12,2,13,7,1,4,10,5],
+    [10,2,8,4,7,6,1,5,15,11,9,14,3,12,13,0],
+    [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],
+    [14,10,4,8,9,15,13,6,1,12,0,2,11,7,5,3],
+];
+struct Blake2b { h: [u64; 8], t: [u64; 2], buf: [u8; 128], buflen: usize, outlen: usize }
+impl Blake2b {
+    fn new(outlen: usize, key: &[u8]) -> Blake2b {
+        let mut h = BLAKE2B_IV;
+        h[0] ^= 0x0101_0000 ^ ((key.len() as u64) << 8) ^ (outlen as u64);
+        let mut s = Blake2b { h, t: [0, 0], buf: [0; 128], buflen: 0, outlen };
+        if !key.is_empty() {
+            let mut block = [0u8; 128];
+            block[..key.len()].copy_from_slice(key);
+            s.update(&block);
+        }
+        s
+    }
+    fn compress(&mut self, last: bool) {
+        let mut m = [0u64; 16];
+        for i in 0..16 { m[i] = u64::from_le_bytes(self.buf[i * 8..i * 8 + 8].try_into().unwrap()); }
+        let mut v = [0u64; 16];
+        v[..8].copy_from_slice(&self.h);
+        v[8..].copy_from_slice(&BLAKE2B_IV);
+        v[12] ^= self.t[0]; v[13] ^= self.t[1];
+        if last { v[14] = !v[14]; }
+        for r in 0..12 {
+            let s = &BLAKE2B_SIGMA[r];
+            macro_rules! g { ($a:expr,$b:expr,$c:expr,$d:expr,$x:expr,$y:expr) => {{
+                v[$a] = v[$a].wrapping_add(v[$b]).wrapping_add($x);
+                v[$d] = (v[$d] ^ v[$a]).rotate_right(32);
+                v[$c] = v[$c].wrapping_add(v[$d]);
+                v[$b] = (v[$b] ^ v[$c]).rotate_right(24);
+                v[$a] = v[$a].wrapping_add(v[$b]).wrapping_add($y);
+                v[$d] = (v[$d] ^ v[$a]).rotate_right(16);
+                v[$c] = v[$c].wrapping_add(v[$d]);
+                v[$b] = (v[$b] ^ v[$c]).rotate_right(63);
+            }}; }
+            g!(0,4,8,12, m[s[0]], m[s[1]]);
+            g!(1,5,9,13, m[s[2]], m[s[3]]);
+            g!(2,6,10,14, m[s[4]], m[s[5]]);
+            g!(3,7,11,15, m[s[6]], m[s[7]]);
+            g!(0,5,10,15, m[s[8]], m[s[9]]);
+            g!(1,6,11,12, m[s[10]], m[s[11]]);
+            g!(2,7,8,13, m[s[12]], m[s[13]]);
+            g!(3,4,9,14, m[s[14]], m[s[15]]);
+        }
+        for i in 0..8 { self.h[i] ^= v[i] ^ v[i + 8]; }
+    }
+    fn update(&mut self, mut data: &[u8]) {
+        while !data.is_empty() {
+            if self.buflen == 128 {
+                self.t[0] = self.t[0].wrapping_add(128);
+                if self.t[0] < 128 { self.t[1] = self.t[1].wrapping_add(1); }
+                self.compress(false);
+                self.buflen = 0;
+            }
+            let take = (128 - self.buflen).min(data.len());
+            self.buf[self.buflen..self.buflen + take].copy_from_slice(&data[..take]);
+            self.buflen += take;
+            data = &data[take..];
+        }
+    }
+    fn finalize(mut self) -> Vec<u8> {
+        self.t[0] = self.t[0].wrapping_add(self.buflen as u64);
+        if self.t[0] < self.buflen as u64 { self.t[1] = self.t[1].wrapping_add(1); }
+        for i in self.buflen..128 { self.buf[i] = 0; }
+        self.compress(true);
+        let mut out = Vec::with_capacity(self.outlen);
+        for i in 0..self.outlen { out.push((self.h[i / 8] >> (8 * (i % 8))) as u8); }
+        out
+    }
+}
+fn blake2b256(data: &[u8]) -> [u8; 32] {
+    let mut b = Blake2b::new(32, &[]); b.update(data);
+    let v = b.finalize(); let mut o = [0u8; 32]; o.copy_from_slice(&v); o
+}
+fn blake2b256_keyed(key: &[u8], data: &[u8]) -> [u8; 32] {
+    let mut b = Blake2b::new(32, key); b.update(data);
+    let v = b.finalize(); let mut o = [0u8; 32]; o.copy_from_slice(&v); o
+}
+fn hex(b: &[u8]) -> String {
+    let mut s = String::with_capacity(b.len() * 2);
+    for &x in b { s.push_str(&format!("{:02x}", x)); }
+    s
+}
+fn dom(tag: &str) -> Vec<u8> {
+    // domain separation: len-prefixed tag
+    let mut v = Vec::new();
+    v.extend_from_slice(&(tag.len() as u64).to_le_bytes());
+    v.extend_from_slice(tag.as_bytes());
+    v
+}
+fn ids_bytes(ids: &[usize]) -> Vec<u8> {
+    let mut v = Vec::with_capacity(ids.len() * 8);
+    for &i in ids { v.extend_from_slice(&(i as u64).to_le_bytes()); }
+    v
+}
+
+// ---------- canonical integer receipt ----------
+struct ReceiptCtx {
+    network_id: [u8; 32],
+    model_hash: [u8; 32],
+    engine_hash: [u8; 32],
+    tables_hash: [u8; 32],
+}
+fn emit_receipt(ctx: &ReceiptCtx, audit_key: &[u8], prompt: &[usize], output: &[usize],
+                eos_reached: bool, arch: &str, ts_millis: u128) -> (String, [u8; 32]) {
+    let ruleset = "qi35-int-v1";
+    // prompt_commitment = blake2b(dom || network || prompt_ids)
+    let mut pb = dom("qi35-prompt/v1"); pb.extend_from_slice(&ctx.network_id); pb.extend_from_slice(&ids_bytes(prompt));
+    let prompt_commit = blake2b256(&pb);
+    // output_commitment = blake2b(dom || network || prompt_commit || output_ids)  [backend-independent]
+    let mut ob = dom("qi35-output/v1"); ob.extend_from_slice(&ctx.network_id);
+    ob.extend_from_slice(&prompt_commit); ob.extend_from_slice(&ids_bytes(output));
+    let output_commit = blake2b256(&ob);
+    // canonical MAC preimage: domain-separated concat of all binding fields
+    let mut mb = dom("qi35-receipt/v0");
+    mb.extend_from_slice(&ctx.network_id);
+    mb.extend_from_slice(&ctx.model_hash);
+    mb.extend_from_slice(&ctx.engine_hash);
+    mb.extend_from_slice(&ctx.tables_hash);
+    mb.extend_from_slice(&dom(ruleset));
+    mb.extend_from_slice(&(prompt.len() as u64).to_le_bytes());
+    mb.extend_from_slice(&(output.len() as u64).to_le_bytes());
+    mb.extend_from_slice(&prompt_commit);
+    mb.extend_from_slice(&output_commit);
+    mb.push(eos_reached as u8);
+    mb.extend_from_slice(&(ts_millis as u64).to_le_bytes());
+    let mac = blake2b256_keyed(audit_key, &mb);
+    // signer key id (public): keyed hash of a fixed label, so the audit key never appears
+    let signer_key_id = blake2b256_keyed(audit_key, &dom("qi35-signer-id/v1"));
+    let json = format!(
+        "{{\"schema\":\"palw.canonical-integer-receipt/v0\",\"class\":\"canonical_integer_v0\",\
+\"network_id\":\"{}\",\"timestamp_millis\":{},\"backend\":\"rust-cpu-{}\",\
+\"model_blake2b256\":\"{}\",\"engine_blake2b256\":\"{}\",\"tables_blake2b256\":\"{}\",\
+\"ruleset_id\":\"{}\",\"prompt_tokens\":{},\"output_tokens\":{},\"eos_reached\":{},\
+\"prompt_commitment\":\"{}\",\"output_commitment\":\"{}\",\
+\"signer_key_id\":\"{}\",\"mac_scheme\":\"keyed-blake2b-256\",\"mac\":\"{}\"}}",
+        hex(&ctx.network_id), ts_millis, arch,
+        hex(&ctx.model_hash), hex(&ctx.engine_hash), hex(&ctx.tables_hash),
+        ruleset, prompt.len(), output.len(), eos_reached,
+        hex(&prompt_commit), hex(&output_commit), hex(&signer_key_id), hex(&mac),
+    );
+    (json, output_commit)
+}
+
+fn hash_file_stream(path: &str) -> [u8; 32] {
+    use std::io::Read;
+    let mut f = std::fs::File::open(path).unwrap();
+    let mut b = Blake2b::new(32, &[]);
+    let mut buf = vec![0u8; 1 << 22];
+    loop {
+        let n = f.read(&mut buf).unwrap();
+        if n == 0 { break; }
+        b.update(&buf[..n]);
+    }
+    let v = b.finalize(); let mut o = [0u8; 32]; o.copy_from_slice(&v); o
+}
+
+fn parse_ids(s: &str) -> Vec<usize> {
+    s.split(|c| c == ',' || c == ' ').filter(|x| !x.is_empty()).map(|x| x.parse().unwrap()).collect()
+}
+fn now_millis() -> u128 {
+    std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_millis()
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.get(1).map(|s| s.as_str()) == Some("--hash-check") {
+        // qi35_model --hash-check <file> [<keyhex>]  -> blake2b256 (keyed if key given)
+        let data = std::fs::read(&args[2]).unwrap();
+        let out = if let Some(kh) = args.get(3) {
+            let key: Vec<u8> = (0..kh.len()/2).map(|i| u8::from_str_radix(&kh[2*i..2*i+2], 16).unwrap()).collect();
+            blake2b256_keyed(&key, &data)
+        } else { blake2b256(&data) };
+        println!("{}", hex(&out));
+        return;
+    }
+    let model_path = args.get(1).expect("gguf path").clone();
+    let tables_path = args.get(2).expect("tables path").clone();
+    let mut ids: Vec<usize> = vec![9419, 11, 1814];
+    let mut ndecode = 4usize;
+    let mut nthreads = 8usize;
+    let mut eos: Option<usize> = None;
+    let mut serve = false;
+    let mut audit_key_file: Option<String> = None;
+    let mut network_label = "MISAKA-Qwen-PALW-v1".to_string();
+    let mut i = 3;
+    while i < args.len() {
+        match args[i].as_str() {
+            "--ids" => { ids = parse_ids(&args[i + 1]); i += 2; }
+            "--ndecode" | "--max-new" => { ndecode = args[i + 1].parse().unwrap(); i += 2; }
+            "--threads" => { nthreads = args[i + 1].parse().unwrap(); i += 2; }
+            "--eos" => { eos = Some(args[i + 1].parse().unwrap()); i += 2; }
+            "--serve" => { serve = true; i += 1; }
+            "--audit-key-file" => { audit_key_file = Some(args[i + 1].clone()); i += 2; }
+            "--network" => { network_label = args[i + 1].clone(); i += 2; }
+            "--metal" => { unsafe { METAL = true; } i += 1; }
+            "--metal-v3" => { unsafe { METAL = true; METAL_V3 = true; } i += 1; }
+            _ => { i += 1; }
+        }
+    }
+    #[cfg(not(target_os = "macos"))]
+    if unsafe { METAL } {
+        eprintln!("--metal and --metal-v3 are supported only on macOS");
+        std::process::exit(2);
+    }
+    unsafe { NTHREADS = nthreads; }
+    let arch = std::env::consts::ARCH;
+
+    // hashes: engine binary + tables (cheap); model (24GB, once).
+    let engine_hash = std::env::current_exe().ok().map(|p| hash_file_stream(p.to_str().unwrap())).unwrap_or([0; 32]);
+    let tables_hash = hash_file_stream(&tables_path);
+    let audit_key: Option<Vec<u8>> = audit_key_file.as_ref().map(|p| std::fs::read(p).unwrap());
+    let network_id = blake2b256(&{ let mut v = dom("misaka-network-id/v1"); v.extend_from_slice(network_label.as_bytes()); v });
+
+    let g = Gguf::open(&model_path);
+    if std::env::var("QI35_SELFTEST").is_ok() {
+        unsafe { METAL = true; }
+        let rc = unsafe { qi35_metal_init(g.data.as_ptr(), g.data.len() as u64) };
+        assert_eq!(rc, 0);
+        for (name, rows) in [("blk.0.attn_qkv.weight", 512usize), ("blk.0.ffn_down_exps.weight", 512), ("output.weight", 512), ("blk.0.ssm_out.weight", 512), ("blk.3.attn_output.weight", 512)] {
+            let k = g.t(name).ne[0];
+            let x: Vec<i64> = (0..k).map(|i| ((i as i64 * 2654435761) % 1000003) - 500000).collect();
+            let cpu = gemm_rows_cpu(&g, name, 0, rows, &x);
+            unsafe { METAL = true; }
+            let gpu = gemm_batch(&g, &[(name, 0, rows, &x)]).pop().unwrap();
+            let mut bad = 0;
+            for r in 0..rows {
+                if cpu[r] != gpu[r] {
+                    if bad < 3 {
+                        eprintln!("MISMATCH {} row {}: cpu=({}, {}) gpu=({}, {})", name, r, cpu[r].0, cpu[r].1, gpu[r].0, gpu[r].1);
+                    }
+                    bad += 1;
+                }
+            }
+            eprintln!("SELFTEST {} rows={} mismatches={}", name, rows, bad);
+        }
+        // multi-gemm batch with nonzero row0 (mimics the MoE phase-1 shape)
+        {
+            let gname = "blk.0.ffn_gate_exps.weight"; let uname = "blk.0.ffn_up_exps.weight";
+            let k = g.t(gname).ne[0];
+            let x: Vec<i64> = (0..k).map(|i| ((i as i64 * 40503) % 900001) - 450000).collect();
+            let sel = [3usize, 17, 42, 99, 128, 200, 231, 255];
+            let mut items: Vec<(&str, usize, usize, &[i64])> = Vec::new();
+            for &e in &sel {
+                items.push((gname, e * FEXP, FEXP, &x));
+                items.push((uname, e * FEXP, FEXP, &x));
+            }
+            unsafe { METAL = true; }
+            let gpu = gemm_batch(&g, &items);
+            unsafe { METAL = false; }
+            let cpu: Vec<Vec<(i128, i32)>> = items.iter().map(|&(n, r0, r, xx)| gemm_rows_cpu(&g, n, r0, r, xx)).collect();
+            let mut bad = 0;
+            for (i, (cv, gv)) in cpu.iter().zip(&gpu).enumerate() {
+                for r in 0..cv.len() {
+                    if cv[r] != gv[r] { if bad < 3 { eprintln!("BATCH MISMATCH item {} row {}: cpu=({},{}) gpu=({},{})", i, r, cv[r].0, cv[r].1, gv[r].0, gv[r].1); } bad += 1; }
+                }
+            }
+            eprintln!("SELFTEST batch16(row0!=0) mismatches={}", bad);
+        }
+        return;
+    }
+    if unsafe { METAL } {
+        let rc = unsafe { qi35_metal_init(g.data.as_ptr(), g.data.len() as u64) };
+        assert_eq!(rc, 0, "metal init failed ({rc})");
+        eprintln!("metal offload: ON");
+    }
+    let tb = load_tables(&tables_path);
+    let mut m = Model::new(g, tb);
+    if unsafe { METAL_V3 } {
+        let rc = unsafe { qi35_moe_init(m.tb.sig.as_ptr(), m.tb.expn.as_ptr()) };
+        assert_eq!(rc, 0, "moe v3 init failed");
+        for l in 0..NL {
+            unsafe { qi35_moe_upload_router(l as u32, m.layers[l].router30.as_ptr() as *const i64, m.layers[l].shexp30.as_ptr() as *const i64); }
+        }
+        let rc = unsafe { qi35_dn_init(m.tb.sig.as_ptr(), m.tb.softplus.as_ptr(), m.tb.gamma.as_ptr()) };
+        assert_eq!(rc, 0, "dn v3 init failed");
+        for l in 0..NL {
+            if m.layers[l].is_attn { continue; }
+            let w30: Vec<i64> = m.layers[l].convw30.iter().map(|&v| i64::try_from(v).unwrap()).collect();
+            let nrm: Vec<i64> = m.layers[l].ssm_norm.iter().map(|&v| i64::try_from(v).unwrap()).collect();
+            let dt16: Vec<i64> = m.layers[l].ssm_dt16.iter().map(|&v| i64::try_from(v).unwrap()).collect();
+            let a30: Vec<i64> = m.layers[l].ssm_a30.iter().map(|&v| i64::try_from(v).unwrap()).collect();
+            unsafe {
+                qi35_dn_upload_layer(l as u32, w30.as_ptr(), nrm.as_ptr(), dt16.as_ptr(), a30.as_ptr());
+                let rc = qi35_dn_bind_state(l as u32,
+                    m.dstates[l].s.as_mut_ptr(), (m.dstates[l].s.len() * 8) as u64,
+                    m.dstates[l].conv.as_mut_ptr(), (m.dstates[l].conv.len() * 8) as u64);
+                assert_eq!(rc, 0, "dn bind_state failed layer {}", l);
+            }
+        }
+        if at_cpu() {
+            eprintln!("metal v3 (moe+deltanet on-device, attention on CPU path via QI35_AT_CPU): ON");
+        } else {
+            let rc = unsafe {
+                qi35_at_init(m.tb.sig.as_ptr(), m.tb.expn.as_ptr(),
+                             m.tb.cos.as_ptr(), m.tb.sin.as_ptr(), m.tb.smax as u32)
+            };
+            assert_eq!(rc, 0, "at v3 init failed");
+            for l in 0..NL {
+                if !m.layers[l].is_attn { continue; }
+                let qn: Vec<i64> = m.layers[l].qnorm.iter().map(|&v| i64::try_from(v).unwrap()).collect();
+                let kn: Vec<i64> = m.layers[l].knorm.iter().map(|&v| i64::try_from(v).unwrap()).collect();
+                let cap = m.kvstates[l].k16.len() / (NKV * HD);
+                let b0 = round4(kvbind0()).min(cap).max(4);
+                unsafe {
+                    qi35_at_upload_layer(l as u32, qn.as_ptr(), kn.as_ptr());
+                    let rc = qi35_at_bind_kv(l as u32,
+                        m.kvstates[l].k16.as_mut_ptr(), (b0 * NKV * HD * 8) as u64,
+                        m.kvstates[l].v16.as_mut_ptr(), (b0 * NKV * HD * 8) as u64);
+                    assert_eq!(rc, 0, "at bind_kv failed layer {}", l);
+                }
+                m.kvstates[l].bound = b0;
+            }
+            eprintln!("metal v3 (moe+deltanet+attention on-device): ON (kv bind0 {} rows/layer)", round4(kvbind0()));
+        }
+    }
+
+    // model hash (over the whole gguf) — needed only when issuing receipts
+    let want_receipt = audit_key.is_some();
+    let model_hash = if want_receipt {
+        eprintln!("hashing model (blake2b, ~once)...");
+        let t = std::time::Instant::now();
+        let h = hash_file_stream(&model_path);
+        eprintln!("model_blake2b256={} ({:.1}s)", hex(&h), t.elapsed().as_secs_f64());
+        h
+    } else { [0; 32] };
+    let rctx = ReceiptCtx { network_id, model_hash, engine_hash, tables_hash };
+
+    if serve {
+        use std::io::{BufRead, Write};
+        eprintln!("SERVE_READY backend=rust-cpu-{} receipts={}", arch, want_receipt);
+        println!("SERVE_READY"); let _ = std::io::stdout().flush();
+        let stdin = std::io::stdin();
+        for line in stdin.lock().lines() {
+            let line = match line { Ok(l) => l, Err(_) => break };
+            let line = line.trim();
+            if line.is_empty() { continue; }
+            if line == "/quit" { break; }
+            // request line: comma/space-separated prompt ids
+            let prompt = parse_ids(line);
+            if prompt.is_empty() { println!("ERR empty prompt"); let _ = std::io::stdout().flush(); continue; }
+            m.reset();
+            let t = std::time::Instant::now();
+            let out = m.generate(&prompt, ndecode, eos, false);
+            let eos_reached = out.len() < ndecode;
+            let secs = t.elapsed().as_secs_f64();
+            let idstr = out.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(",");
+            println!("GEN {}", idstr);
+            if let Some(k) = &audit_key {
+                let (json, _c) = emit_receipt(&rctx, k, &prompt, &out, eos_reached, arch, now_millis());
+                println!("RCPT {}", json);
+            }
+            println!("DONE {:.2}s {}tok", secs, out.len());
+            let _ = std::io::stdout().flush();
+        }
+        return;
+    }
+
+    // one-shot
+    m.reset();
+    let t0 = std::time::Instant::now();
+    let gen = m.generate(&ids, ndecode, eos, true);
+    if std::env::var("QI35_PROF").is_ok() {
+        eprintln!("PROF gpu_batch_wall = {:.2}s over {} commits, moe_gpu_wall = {:.2}s, dn_gpu_wall = {:.2}s, at_gpu_wall = {:.2}s",
+            GPU_NS.load(std::sync::atomic::Ordering::Relaxed) as f64 / 1e9,
+            GPU_COMMITS.load(std::sync::atomic::Ordering::Relaxed),
+            GPU_XCONV_NS.load(std::sync::atomic::Ordering::Relaxed) as f64 / 1e9,
+            GPU_DN_NS.load(std::sync::atomic::Ordering::Relaxed) as f64 / 1e9,
+            GPU_AT_NS.load(std::sync::atomic::Ordering::Relaxed) as f64 / 1e9);
+    }
+    let bytes: Vec<u8> = gen.iter().flat_map(|&t| (t as i64).to_le_bytes()).collect();
+    println!("generated = {:?}", gen);
+    println!("ids FNV   = {:016x}", fnv(&bytes));
+    println!("eos_reached = {}", gen.len() < ndecode);
+    let (rr, kvr, sr) = m.execution_roots();
+    println!("route_root = {}", hex(&rr));
+    println!("kv_root = {}", hex(&kvr));
+    println!("state_root = {}", hex(&sr));
+    if let Some(k) = &audit_key {
+        let (json, commit) = emit_receipt(&rctx, k, &ids, &gen, gen.len() < ndecode, arch, now_millis());
+        println!("output_commitment = {}", hex(&commit));
+        println!("receipt = {}", json);
+    }
+    println!("total {:.1}s", t0.elapsed().as_secs_f64());
+}
diff --git a/docs/evidence/qi35_verify.py b/docs/evidence/qi35_verify.py
new file mode 100644
index 0000000000000000000000000000000000000000..94370e2d2fb273c40de181d5dc2537a089048d6c
--- /dev/null
+++ b/docs/evidence/qi35_verify.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# QI35 canonical-integer receipt verifier. Independently RE-RUNS the integer engine on the receipt's
+# prompt (the "opening") and checks the recomputed output_commitment + MAC + prompt_commitment match.
+# Because the integer forward is backend-independent, this passes on ANY hardware (Mac/x86/CUDA) that
+# runs the same canonical engine — that is the whole point of the canonical class.
+#
+#   python3 qi35_verify.py --receipt R.json --opening O.json --audit-key KEY [--model M --tables T --engine E]
+import sys, os, json, subprocess, hashlib, argparse
+
+def dom(t): return len(t).to_bytes(8, "little") + t.encode()
+def ids_bytes(ids): return b"".join(int(i).to_bytes(8, "little") for i in ids)
+
+def prompt_commit(nid, ids):
+    return hashlib.blake2b(dom("qi35-prompt/v1") + nid + ids_bytes(ids), digest_size=32).hexdigest()
+def output_commit(nid, pc_hex, oids):
+    return hashlib.blake2b(dom("qi35-output/v1") + nid + bytes.fromhex(pc_hex) + ids_bytes(oids), digest_size=32).hexdigest()
+def recompute_mac(r, akey):
+    nid = bytes.fromhex(r["network_id"])
+    mb  = dom("qi35-receipt/v0") + nid
+    mb += bytes.fromhex(r["model_blake2b256"]) + bytes.fromhex(r["engine_blake2b256"]) + bytes.fromhex(r["tables_blake2b256"])
+    mb += dom(r["ruleset_id"])
+    mb += r["prompt_tokens"].to_bytes(8, "little") + r["output_tokens"].to_bytes(8, "little")
+    mb += bytes.fromhex(r["prompt_commitment"]) + bytes.fromhex(r["output_commitment"])
+    mb += bytes([1 if r["eos_reached"] else 0]) + int(r["timestamp_millis"]).to_bytes(8, "little")
+    return hashlib.blake2b(mb, digest_size=32, key=akey).hexdigest()
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--receipt", required=True)
+    ap.add_argument("--opening", required=True, help="json with {prompt_ids:[...], output_ids:[...]}")
+    ap.add_argument("--audit-key", required=True)
+    ap.add_argument("--model", default=os.environ.get("QI35_MODEL"))
+    ap.add_argument("--tables", default=os.environ.get("QI35_TABLES"))
+    ap.add_argument("--engine", default=os.environ.get("QI35_ENGINE"))
+    ap.add_argument("--threads", default=os.environ.get("QI35_THREADS", "8"))
+    ap.add_argument("--rerun", action="store_true", help="re-run the engine to reproduce output_commitment")
+    a = ap.parse_args()
+    r = json.load(open(a.receipt)); opening = json.load(open(a.opening))
+    akey = open(a.audit_key, "rb").read()
+    nid = bytes.fromhex(r["network_id"])
+    pids, oids = opening["prompt_ids"], opening["output_ids"]
+    checks = []
+
+    # 1. MAC integrity (receipt record not tampered)
+    checks.append(("MAC", recompute_mac(r, akey) == r["mac"]))
+    # 2. prompt_commitment matches the opening's prompt ids
+    checks.append(("prompt_commitment", prompt_commit(nid, pids) == r["prompt_commitment"]))
+    # 3. output_commitment matches the opening's output ids
+    checks.append(("output_commitment(stored-ids)", output_commit(nid, r["prompt_commitment"], oids) == r["output_commitment"]))
+
+    # 4. (strong) independently RE-RUN the integer engine and reproduce output_commitment
+    if a.rerun:
+        maxnew = max(len(oids) + 1, r["output_tokens"] + 1)
+        cmd = [a.engine, a.model, a.tables, "--ids", ",".join(map(str, pids)),
+               "--max-new", str(maxnew), "--eos", "248046", "--threads", a.threads,
+               "--audit-key-file", a.audit_key]
+        out = subprocess.run(cmd, capture_output=True, text=True)
+        oc = None
+        for ln in out.stdout.splitlines():
+            if ln.startswith("output_commitment = "):
+                oc = ln.split(" = ")[1].strip()
+        checks.append(("output_commitment(re-run)", oc == r["output_commitment"]))
+        # also confirm model/engine/tables hashes reproduce (same artifacts)
+        for ln in out.stdout.splitlines():
+            if ln.startswith("receipt = "):
+                rr = json.loads(ln[len("receipt = "):])
+                checks.append(("model_hash", rr["model_blake2b256"] == r["model_blake2b256"]))
+                checks.append(("engine_hash", rr["engine_blake2b256"] == r["engine_blake2b256"]))
+                checks.append(("tables_hash", rr["tables_blake2b256"] == r["tables_blake2b256"]))
+
+    print(f"receipt class = {r['class']}  out_commit = {r['output_commitment'][:24]}…")
+    allok = True
+    for name, ok in checks:
+        print(f"  [{'PASS' if ok else 'FAIL'}] {name}")
+        allok = allok and ok
+    print("VERIFY:", "PASS" if allok else "FAIL")
+    sys.exit(0 if allok else 1)
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/evidence/reports/qi35-calibration-mac-20260721-final.json b/docs/evidence/reports/qi35-calibration-mac-20260721-final.json
new file mode 100644
index 0000000000000000000000000000000000000000..5a2115ddc8ea7d3da3cc1b980db457a5ab9c0925
--- /dev/null
+++ b/docs/evidence/reports/qi35-calibration-mac-20260721-final.json
@@ -0,0 +1,2055 @@
+{
+  "artifacts": {
+    "corpus": {
+      "basename": "qi35-calibration-prompts-v1.json",
+      "bytes": 1726,
+      "sha256": "7e05acc22fa58445b92ff8e9edf2466ea9eb107e76f43ae087449d7976b513bd"
+    },
+    "engine": {
+      "basename": "qi35_model-portable-mac",
+      "bytes": 818520,
+      "sha256": "242a3614eea9e129e0ef9a48c5f8ca320c3b6eb4c616e82c50fdc4f6de631660"
+    },
+    "engine_source": {
+      "basename": "qi35_model.rs",
+      "bytes": 100161,
+      "sha256": "098385055c5e1bc6a9cd6229a06a14be53e8403ea89d4f3ba9b53457c210eecd"
+    },
+    "llama_libraries": [
+      {
+        "basename": "libllama-server-impl.dylib",
+        "bytes": 3518936,
+        "sha256": "50270f32da282e10744ca576070111baf84a9b40fd6804c66533647344331f6f"
+      },
+      {
+        "basename": "libllama-common.0.0.10015.dylib",
+        "bytes": 4969832,
+        "sha256": "82f3f6f2f76d023d92849f9b21869130ed8c6618822dbdf2aa3067cdf9057bc4"
+      },
+      {
+        "basename": "libmtmd.0.0.10015.dylib",
+        "bytes": 1029920,
+        "sha256": "d7fa3d3459d9767fcd1007cdf9a981ea34347048659c802f252c26260c6bb4c8"
+      },
+      {
+        "basename": "libllama.0.0.10015.dylib",
+        "bytes": 2663088,
+        "sha256": "47a22694597b7b2e6004aafeb7eb364294b147713bc3ef6f8fc51208013f794b"
+      },
+      {
+        "basename": "libggml.0.16.0.dylib",
+        "bytes": 59808,
+        "sha256": "dbfdb8f69df9e05d54531d41fed4b950a41f67ad4cd0365b899776f3a824e4e1"
+      },
+      {
+        "basename": "libggml-cpu.0.16.0.dylib",
+        "bytes": 934320,
+        "sha256": "172f0c200769b4373be3a8daed008e67cc6b974f3f73e4a5c1a9be31bba45c29"
+      },
+      {
+        "basename": "libggml-blas.0.16.0.dylib",
+        "bytes": 58776,
+        "sha256": "37fc972ce379db614b35f2f115f40358fb7934cc66b981444043087f371d34e2"
+      },
+      {
+        "basename": "libggml-metal.0.16.0.dylib",
+        "bytes": 849400,
+        "sha256": "7821024d78bc4152b6bcd871eeb6bc63207107709fe0c6afd3b6cf6e21677bf0"
+      },
+      {
+        "basename": "libggml-base.0.16.0.dylib",
+        "bytes": 711208,
+        "sha256": "812c578136444f135b8a6b5f113ab012b8b48c27690e09058c326f7ff9b8be73"
+      }
+    ],
+    "llama_patch": {
+      "basename": "llama.cpp-palw-full.patch",
+      "bytes": 305392,
+      "sha256": "25f7062c3a930daf108a146f178c714c8978d92c83fa6d30af1f951705a8f62b"
+    },
+    "llama_server": {
+      "basename": "llama-server",
+      "bytes": 33472,
+      "sha256": "ad2946371ae4abe62115dc514dee11f4655ed117d718b714b338b00d82e039e0"
+    },
+    "model": {
+      "basename": "Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+      "bytes": 23938321728,
+      "sha256": "1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b"
+    },
+    "runner": {
+      "basename": "qi35_calibrate.py",
+      "bytes": 18255,
+      "sha256": "e49d01153996824ad8351c5bbc75b1136270c70005b60705bfb12aa2c44a5a1c"
+    },
+    "soak_library": {
+      "basename": "qi35_soak.py",
+      "bytes": 34889,
+      "sha256": "3c029e869f20474ad53a7abc21e1666b63616424022e504eb43cc522fa1787e3"
+    },
+    "tables": {
+      "basename": "qi35_tables.bin",
+      "bytes": 4849688,
+      "sha256": "feb22fd1864a1396b9c2bc20937f3acad79bffefdefc71c50b3747da47b64c6e"
+    },
+    "tokenizer": {
+      "basename": "tokenizer.json",
+      "bytes": 19989343,
+      "sha256": "87a7830d63fcf43bf241c3c5242e96e62dd3fdc29224ca26fed8ea333db72de4"
+    }
+  },
+  "configuration": {
+    "context_size": 1024,
+    "iterations": 3,
+    "llama_gpu_layers": "all",
+    "llama_library_count": 9,
+    "llama_revision": "12127defda4f41b7679cb2477a4b0d65ee6a0c8f",
+    "max_new": 8,
+    "prompts": [
+      {
+        "ids": [
+          9419,
+          11,
+          1814
+        ],
+        "name": "hello_world",
+        "text": "Hello, world"
+      },
+      {
+        "ids": [
+          760,
+          6511,
+          314,
+          9338,
+          369
+        ],
+        "name": "paris",
+        "text": "The capital of France is"
+      },
+      {
+        "ids": [
+          17,
+          478,
+          220,
+          17,
+          283
+        ],
+        "name": "arithmetic",
+        "text": "2 + 2 ="
+      },
+      {
+        "ids": [
+          27336,
+          90162,
+          506
+        ],
+        "name": "freezing",
+        "text": "Water freezes at"
+      },
+      {
+        "ids": [
+          623,
+          12654,
+          11,
+          264,
+          1103,
+          59036
+        ],
+        "name": "python_comprehension",
+        "text": "In Python, a list comprehension"
+      },
+      {
+        "ids": [
+          161607,
+          110161,
+          14876
+        ],
+        "name": "japanese_capital",
+        "text": "\u65e5\u672c\u306e\u9996\u90fd\u306f"
+      },
+      {
+        "ids": [
+          760,
+          3841,
+          13477,
+          37550
+        ],
+        "name": "quick_fox",
+        "text": "The quick brown fox"
+      },
+      {
+        "ids": [
+          814,
+          20139,
+          22525,
+          303,
+          799,
+          11316,
+          25
+        ],
+        "name": "gravity",
+        "text": "Explain gravity in one sentence:"
+      },
+      {
+        "ids": [
+          49,
+          575,
+          14834,
+          27028
+        ],
+        "name": "rust_ownership",
+        "text": "Rust ownership prevents"
+      },
+      {
+        "ids": [
+          2592,
+          660,
+          18833,
+          513,
+          53702,
+          321,
+          48130,
+          369,
+          264,
+          7993,
+          11,
+          1179,
+          48130,
+          369
+        ],
+        "name": "logic_cat",
+        "text": "If all cats are mammals and Luna is a cat, then Luna is"
+      },
+      {
+        "ids": [
+          727,
+          73111,
+          1393,
+          1590
+        ],
+        "name": "fibonacci",
+        "text": "def fibonacci(n):"
+      },
+      {
+        "ids": [
+          26583,
+          1603,
+          6353,
+          310,
+          8323,
+          25
+        ],
+        "name": "french_translation",
+        "text": "Translate good morning to French:"
+      }
+    ],
+    "sampling": {
+      "cache_prompt": false,
+      "dry_multiplier": 0.0,
+      "frequency_penalty": 0.0,
+      "ignore_eos": true,
+      "min_p": 0.0,
+      "presence_penalty": 0.0,
+      "raw_token_input_output": true,
+      "repeat_penalty": 1.0,
+      "temperature": 0.0,
+      "top_k": 0,
+      "top_p": 1.0
+    },
+    "threads": 8
+  },
+  "failures": [],
+  "finished_at_utc": "2026-07-21T03:46:14.575264Z",
+  "fp_measurements": [
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 0,
+      "predicted_ms": 159.468,
+      "predicted_per_second": 50.16680462537939,
+      "prompt": "hello_world",
+      "prompt_ms": 43.024,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 0,
+      "predicted_ms": 155.082,
+      "predicted_per_second": 51.58561277259773,
+      "prompt": "paris",
+      "prompt_ms": 75.595,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 0,
+      "predicted_ms": 157.711,
+      "predicted_per_second": 50.7256944664608,
+      "prompt": "arithmetic",
+      "prompt_ms": 71.617,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 0,
+      "predicted_ms": 159.129,
+      "predicted_per_second": 50.27367733097047,
+      "prompt": "freezing",
+      "prompt_ms": 40.727,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 0,
+      "predicted_ms": 149.133,
+      "predicted_per_second": 53.64339213990196,
+      "prompt": "python_comprehension",
+      "prompt_ms": 76.882,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 0,
+      "predicted_ms": 157.863,
+      "predicted_per_second": 50.67685271406219,
+      "prompt": "japanese_capital",
+      "prompt_ms": 43.583,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        271,
+        2
+      ],
+      "iteration": 0,
+      "predicted_ms": 157.925,
+      "predicted_per_second": 50.65695741649517,
+      "prompt": "quick_fox",
+      "prompt_ms": 50.858,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 0,
+      "predicted_ms": 154.004,
+      "predicted_per_second": 51.9467026830472,
+      "prompt": "gravity",
+      "prompt_ms": 90.134,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 0,
+      "predicted_ms": 158.882,
+      "predicted_per_second": 50.35183343613499,
+      "prompt": "rust_ownership",
+      "prompt_ms": 47.714,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 0,
+      "predicted_ms": 160.05,
+      "predicted_per_second": 49.9843798812871,
+      "prompt": "logic_cat",
+      "prompt_ms": 142.981,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 0,
+      "predicted_ms": 170.99,
+      "predicted_per_second": 46.786361775542424,
+      "prompt": "fibonacci",
+      "prompt_ms": 57.873,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 0,
+      "predicted_ms": 184.902,
+      "predicted_per_second": 43.2661626158722,
+      "prompt": "french_translation",
+      "prompt_ms": 80.783,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 1,
+      "predicted_ms": 153.368,
+      "predicted_per_second": 52.16211986855146,
+      "prompt": "hello_world",
+      "prompt_ms": 40.888,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 1,
+      "predicted_ms": 243.495,
+      "predicted_per_second": 32.85488408386209,
+      "prompt": "paris",
+      "prompt_ms": 68.399,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 1,
+      "predicted_ms": 172.235,
+      "predicted_per_second": 46.448166748918624,
+      "prompt": "arithmetic",
+      "prompt_ms": 87.428,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 1,
+      "predicted_ms": 211.059,
+      "predicted_per_second": 37.90409316826101,
+      "prompt": "freezing",
+      "prompt_ms": 41.095,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 1,
+      "predicted_ms": 186.975,
+      "predicted_per_second": 42.786468779248565,
+      "prompt": "python_comprehension",
+      "prompt_ms": 77.222,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 1,
+      "predicted_ms": 181.03,
+      "predicted_per_second": 44.19157045793515,
+      "prompt": "japanese_capital",
+      "prompt_ms": 39.936,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        271,
+        2
+      ],
+      "iteration": 1,
+      "predicted_ms": 153.441,
+      "predicted_per_second": 52.13730358900163,
+      "prompt": "quick_fox",
+      "prompt_ms": 45.269,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 1,
+      "predicted_ms": 173.027,
+      "predicted_per_second": 46.235558612239714,
+      "prompt": "gravity",
+      "prompt_ms": 89.922,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 1,
+      "predicted_ms": 181.153,
+      "predicted_per_second": 44.16156508586665,
+      "prompt": "rust_ownership",
+      "prompt_ms": 45.676,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 1,
+      "predicted_ms": 219.314,
+      "predicted_per_second": 36.47737946505923,
+      "prompt": "logic_cat",
+      "prompt_ms": 142.952,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 1,
+      "predicted_ms": 157.093,
+      "predicted_per_second": 50.925248101443096,
+      "prompt": "fibonacci",
+      "prompt_ms": 46.393,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 1,
+      "predicted_ms": 170.251,
+      "predicted_per_second": 46.98944499591779,
+      "prompt": "french_translation",
+      "prompt_ms": 76.566,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 2,
+      "predicted_ms": 154.449,
+      "predicted_per_second": 51.79703332491631,
+      "prompt": "hello_world",
+      "prompt_ms": 39.477,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 2,
+      "predicted_ms": 152.562,
+      "predicted_per_second": 52.4376974607045,
+      "prompt": "paris",
+      "prompt_ms": 70.838,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 2,
+      "predicted_ms": 156.483,
+      "predicted_per_second": 51.12376424276119,
+      "prompt": "arithmetic",
+      "prompt_ms": 67.434,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 2,
+      "predicted_ms": 153.983,
+      "predicted_per_second": 51.953787106368885,
+      "prompt": "freezing",
+      "prompt_ms": 39.682,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 2,
+      "predicted_ms": 155.508,
+      "predicted_per_second": 51.44429868559816,
+      "prompt": "python_comprehension",
+      "prompt_ms": 78.235,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 2,
+      "predicted_ms": 160.471,
+      "predicted_per_second": 49.85324451146936,
+      "prompt": "japanese_capital",
+      "prompt_ms": 40.033,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        271,
+        2
+      ],
+      "iteration": 2,
+      "predicted_ms": 156.034,
+      "predicted_per_second": 51.270876860171505,
+      "prompt": "quick_fox",
+      "prompt_ms": 46.651,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 2,
+      "predicted_ms": 157.347,
+      "predicted_per_second": 50.84304117650797,
+      "prompt": "gravity",
+      "prompt_ms": 83.331,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 2,
+      "predicted_ms": 155.322,
+      "predicted_per_second": 51.50590386423043,
+      "prompt": "rust_ownership",
+      "prompt_ms": 46.124,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 2,
+      "predicted_ms": 157.046,
+      "predicted_per_second": 50.94048877398979,
+      "prompt": "logic_cat",
+      "prompt_ms": 136.725,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 2,
+      "predicted_ms": 160.754,
+      "predicted_per_second": 49.76548017467684,
+      "prompt": "fibonacci",
+      "prompt_ms": 46.978,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 2,
+      "predicted_ms": 159.625,
+      "predicted_per_second": 50.11746280344558,
+      "prompt": "french_translation",
+      "prompt_ms": 77.877,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    }
+  ],
+  "host": {
+    "hw.memsize": "34359738368",
+    "hw.model": "Mac13,1",
+    "machdep.cpu.brand_string": "Apple M1 Max",
+    "machine": "arm64",
+    "python": "3.14.4",
+    "release": "25.5.0",
+    "system": "Darwin"
+  },
+  "integer_measurements": [
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 0,
+      "prompt": "hello_world",
+      "seconds": 4.82,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 0,
+      "prompt": "paris",
+      "seconds": 4.54,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 0,
+      "prompt": "arithmetic",
+      "seconds": 4.51,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 0,
+      "prompt": "freezing",
+      "seconds": 3.78,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 0,
+      "prompt": "python_comprehension",
+      "seconds": 4.8,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 0,
+      "prompt": "japanese_capital",
+      "seconds": 3.79,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 0,
+      "prompt": "quick_fox",
+      "seconds": 4.11,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 0,
+      "prompt": "gravity",
+      "seconds": 5.22,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 0,
+      "prompt": "rust_ownership",
+      "seconds": 4.18,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 0,
+      "prompt": "logic_cat",
+      "seconds": 7.78,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 0,
+      "prompt": "fibonacci",
+      "seconds": 4.33,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 0,
+      "prompt": "french_translation",
+      "seconds": 4.87,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 1,
+      "prompt": "hello_world",
+      "seconds": 3.9,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 1,
+      "prompt": "paris",
+      "seconds": 4.62,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 1,
+      "prompt": "arithmetic",
+      "seconds": 4.85,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 1,
+      "prompt": "freezing",
+      "seconds": 3.98,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 1,
+      "prompt": "python_comprehension",
+      "seconds": 5.31,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 1,
+      "prompt": "japanese_capital",
+      "seconds": 4.03,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 1,
+      "prompt": "quick_fox",
+      "seconds": 4.37,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 1,
+      "prompt": "gravity",
+      "seconds": 5.54,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 1,
+      "prompt": "rust_ownership",
+      "seconds": 4.49,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 1,
+      "prompt": "logic_cat",
+      "seconds": 8.01,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 1,
+      "prompt": "fibonacci",
+      "seconds": 4.46,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 1,
+      "prompt": "french_translation",
+      "seconds": 4.91,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 2,
+      "prompt": "hello_world",
+      "seconds": 3.92,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 2,
+      "prompt": "paris",
+      "seconds": 4.65,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 2,
+      "prompt": "arithmetic",
+      "seconds": 4.62,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 2,
+      "prompt": "freezing",
+      "seconds": 3.84,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 2,
+      "prompt": "python_comprehension",
+      "seconds": 4.87,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 2,
+      "prompt": "japanese_capital",
+      "seconds": 3.86,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 2,
+      "prompt": "quick_fox",
+      "seconds": 4.15,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 2,
+      "prompt": "gravity",
+      "seconds": 5.21,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 2,
+      "prompt": "rust_ownership",
+      "seconds": 4.2,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 2,
+      "prompt": "logic_cat",
+      "seconds": 7.6,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 2,
+      "prompt": "fibonacci",
+      "seconds": 4.21,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 2,
+      "prompt": "french_translation",
+      "seconds": 4.86,
+      "tokens": 8
+    }
+  ],
+  "integer_stderr_tail": [
+    "qi35metal: maxBufferLength=20100448256",
+    "metal offload: ON",
+    "metal v3 (moe+deltanet+attention on-device): ON (kv bind0 1024 rows/layer)",
+    "SERVE_READY backend=rust-cpu-aarch64 receipts=false"
+  ],
+  "llama_log_tail": [
+    "0.08.142.496 I slot print_timing: id  0 | task 123 | prompt eval time =      68.40 ms /     5 tokens (   13.68 ms per token,    73.10 tokens per second)",
+    "0.08.142.501 I slot print_timing: id  0 | task 123 |        eval time =     243.50 ms /     8 tokens (   30.44 ms per token,    32.85 tokens per second)",
+    "0.08.142.502 I slot print_timing: id  0 | task 123 |       total time =     311.89 ms /    13 tokens",
+    "0.08.142.502 I slot print_timing: id  0 | task 123 |    graphs reused =         84",
+    "0.08.142.515 I slot      release: id  0 | task 123 | stop processing: n_tokens = 12, truncated = 0",
+    "0.08.144.492 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47859970654",
+    "0.08.289.999 I slot launch_slot_: id  0 | task 133 | processing task, is_child = 0",
+    "0.08.549.687 I slot print_timing: id  0 | task 133 | prompt eval time =      87.43 ms /     5 tokens (   17.49 ms per token,    57.19 tokens per second)",
+    "0.08.549.697 I slot print_timing: id  0 | task 133 |        eval time =     172.24 ms /     8 tokens (   21.53 ms per token,    46.45 tokens per second)",
+    "0.08.549.698 I slot print_timing: id  0 | task 133 |       total time =     259.66 ms /    13 tokens",
+    "0.08.549.698 I slot print_timing: id  0 | task 133 |    graphs reused =         90",
+    "0.08.549.728 I slot      release: id  0 | task 133 | stop processing: n_tokens = 12, truncated = 0",
+    "0.08.560.907 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47860377866",
+    "0.08.637.923 I slot launch_slot_: id  0 | task 143 | processing task, is_child = 0",
+    "0.08.890.103 I slot print_timing: id  0 | task 143 | prompt eval time =      41.09 ms /     3 tokens (   13.70 ms per token,    73.00 tokens per second)",
+    "0.08.890.110 I slot print_timing: id  0 | task 143 |        eval time =     211.06 ms /     8 tokens (   26.38 ms per token,    37.90 tokens per second)",
+    "0.08.890.110 I slot print_timing: id  0 | task 143 |       total time =     252.15 ms /    11 tokens",
+    "0.08.890.111 I slot print_timing: id  0 | task 143 |    graphs reused =         96",
+    "0.08.890.145 I slot      release: id  0 | task 143 | stop processing: n_tokens = 10, truncated = 0",
+    "0.08.905.109 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47860718283",
+    "0.09.029.847 I slot launch_slot_: id  0 | task 152 | processing task, is_child = 0",
+    "0.09.294.084 I slot print_timing: id  0 | task 152 | prompt eval time =      77.22 ms /     6 tokens (   12.87 ms per token,    77.70 tokens per second)",
+    "0.09.294.089 I slot print_timing: id  0 | task 152 |        eval time =     186.97 ms /     8 tokens (   23.37 ms per token,    42.79 tokens per second)",
+    "0.09.294.089 I slot print_timing: id  0 | task 152 |       total time =     264.20 ms /    14 tokens",
+    "0.09.294.090 I slot print_timing: id  0 | task 152 |    graphs reused =        102",
+    "0.09.294.137 I slot      release: id  0 | task 152 | stop processing: n_tokens = 13, truncated = 0",
+    "0.09.295.696 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47861122276",
+    "0.09.353.730 I slot launch_slot_: id  0 | task 162 | processing task, is_child = 0",
+    "0.09.574.742 I slot print_timing: id  0 | task 162 | prompt eval time =      39.94 ms /     3 tokens (   13.31 ms per token,    75.12 tokens per second)",
+    "0.09.574.752 I slot print_timing: id  0 | task 162 |        eval time =     181.03 ms /     8 tokens (   22.63 ms per token,    44.19 tokens per second)",
+    "0.09.574.753 I slot print_timing: id  0 | task 162 |       total time =     220.97 ms /    11 tokens",
+    "0.09.574.754 I slot print_timing: id  0 | task 162 |    graphs reused =        108",
+    "0.09.574.795 I slot      release: id  0 | task 162 | stop processing: n_tokens = 10, truncated = 0",
+    "0.09.587.388 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47861402933",
+    "0.09.635.449 I slot launch_slot_: id  0 | task 171 | processing task, is_child = 0",
+    "0.09.834.182 I slot print_timing: id  0 | task 171 | prompt eval time =      45.27 ms /     4 tokens (   11.32 ms per token,    88.36 tokens per second)",
+    "0.09.834.186 I slot print_timing: id  0 | task 171 |        eval time =     153.44 ms /     8 tokens (   19.18 ms per token,    52.14 tokens per second)",
+    "0.09.834.186 I slot print_timing: id  0 | task 171 |       total time =     198.71 ms /    12 tokens",
+    "0.09.834.187 I slot print_timing: id  0 | task 171 |    graphs reused =        114",
+    "0.09.834.241 I slot      release: id  0 | task 171 | stop processing: n_tokens = 11, truncated = 0",
+    "0.09.835.675 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47861662379",
+    "0.09.887.219 I slot launch_slot_: id  0 | task 180 | processing task, is_child = 0",
+    "0.10.150.190 I slot print_timing: id  0 | task 180 | prompt eval time =      89.92 ms /     7 tokens (   12.85 ms per token,    77.85 tokens per second)",
+    "0.10.150.196 I slot print_timing: id  0 | task 180 |        eval time =     173.03 ms /     8 tokens (   21.63 ms per token,    46.24 tokens per second)",
+    "0.10.150.196 I slot print_timing: id  0 | task 180 |       total time =     262.95 ms /    15 tokens",
+    "0.10.150.197 I slot print_timing: id  0 | task 180 |    graphs reused =        120",
+    "0.10.150.246 I slot      release: id  0 | task 180 | stop processing: n_tokens = 14, truncated = 0",
+    "0.10.160.377 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47861978384",
+    "0.10.246.684 I slot launch_slot_: id  0 | task 190 | processing task, is_child = 0",
+    "0.10.473.555 I slot print_timing: id  0 | task 190 | prompt eval time =      45.68 ms /     4 tokens (   11.42 ms per token,    87.57 tokens per second)",
+    "0.10.473.559 I slot print_timing: id  0 | task 190 |        eval time =     181.15 ms /     8 tokens (   22.64 ms per token,    44.16 tokens per second)",
+    "0.10.473.560 I slot print_timing: id  0 | task 190 |       total time =     226.83 ms /    12 tokens",
+    "0.10.473.561 I slot print_timing: id  0 | task 190 |    graphs reused =        126",
+    "0.10.473.588 I slot      release: id  0 | task 190 | stop processing: n_tokens = 11, truncated = 0",
+    "0.10.516.737 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47862301726",
+    "0.10.565.773 I slot launch_slot_: id  0 | task 199 | processing task, is_child = 0",
+    "0.10.928.091 I slot print_timing: id  0 | task 199 | prompt eval time =     142.95 ms /    14 tokens (   10.21 ms per token,    97.93 tokens per second)",
+    "0.10.928.096 I slot print_timing: id  0 | task 199 |        eval time =     219.31 ms /     8 tokens (   27.41 ms per token,    36.48 tokens per second)",
+    "0.10.928.096 I slot print_timing: id  0 | task 199 |       total time =     362.27 ms /    22 tokens",
+    "0.10.928.097 I slot print_timing: id  0 | task 199 |    graphs reused =        132",
+    "0.10.928.152 I slot      release: id  0 | task 199 | stop processing: n_tokens = 21, truncated = 0",
+    "0.10.929.866 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47862756290",
+    "0.10.987.213 I slot launch_slot_: id  0 | task 209 | processing task, is_child = 0",
+    "0.11.190.718 I slot print_timing: id  0 | task 209 | prompt eval time =      46.39 ms /     4 tokens (   11.60 ms per token,    86.22 tokens per second)",
+    "0.11.190.723 I slot print_timing: id  0 | task 209 |        eval time =     157.09 ms /     8 tokens (   19.64 ms per token,    50.93 tokens per second)",
+    "0.11.190.724 I slot print_timing: id  0 | task 209 |       total time =     203.49 ms /    12 tokens",
+    "0.11.190.724 I slot print_timing: id  0 | task 209 |    graphs reused =        138",
+    "0.11.190.751 I slot      release: id  0 | task 209 | stop processing: n_tokens = 11, truncated = 0",
+    "0.11.191.518 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47863018892",
+    "0.11.230.023 I slot launch_slot_: id  0 | task 218 | processing task, is_child = 0",
+    "0.11.476.858 I slot print_timing: id  0 | task 218 | prompt eval time =      76.57 ms /     6 tokens (   12.76 ms per token,    78.36 tokens per second)",
+    "0.11.476.863 I slot print_timing: id  0 | task 218 |        eval time =     170.25 ms /     8 tokens (   21.28 ms per token,    46.99 tokens per second)",
+    "0.11.476.863 I slot print_timing: id  0 | task 218 |       total time =     246.82 ms /    14 tokens",
+    "0.11.476.864 I slot print_timing: id  0 | task 218 |    graphs reused =        144",
+    "0.11.476.900 I slot      release: id  0 | task 218 | stop processing: n_tokens = 13, truncated = 0",
+    "0.11.477.960 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47863305041",
+    "0.11.526.689 I slot launch_slot_: id  0 | task 228 | processing task, is_child = 0",
+    "0.11.720.636 I slot print_timing: id  0 | task 228 | prompt eval time =      39.48 ms /     3 tokens (   13.16 ms per token,    75.99 tokens per second)",
+    "0.11.720.642 I slot print_timing: id  0 | task 228 |        eval time =     154.45 ms /     8 tokens (   19.31 ms per token,    51.80 tokens per second)",
+    "0.11.720.642 I slot print_timing: id  0 | task 228 |       total time =     193.93 ms /    11 tokens",
+    "0.11.720.643 I slot print_timing: id  0 | task 228 |    graphs reused =        150",
+    "0.11.720.682 I slot      release: id  0 | task 228 | stop processing: n_tokens = 10, truncated = 0",
+    "0.11.721.689 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47863548821",
+    "0.11.744.921 I slot launch_slot_: id  0 | task 237 | processing task, is_child = 0",
+    "0.11.968.345 I slot print_timing: id  0 | task 237 | prompt eval time =      70.84 ms /     5 tokens (   14.17 ms per token,    70.58 tokens per second)",
+    "0.11.968.357 I slot print_timing: id  0 | task 237 |        eval time =     152.56 ms /     8 tokens (   19.07 ms per token,    52.44 tokens per second)",
+    "0.11.968.367 I slot print_timing: id  0 | task 237 |       total time =     223.40 ms /    13 tokens",
+    "0.11.968.367 I slot print_timing: id  0 | task 237 |    graphs reused =        156",
+    "0.11.968.384 I slot      release: id  0 | task 237 | stop processing: n_tokens = 12, truncated = 0",
+    "0.11.969.290 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47863796523",
+    "0.12.008.641 I slot launch_slot_: id  0 | task 247 | processing task, is_child = 0",
+    "0.12.232.581 I slot print_timing: id  0 | task 247 | prompt eval time =      67.43 ms /     5 tokens (   13.49 ms per token,    74.15 tokens per second)",
+    "0.12.232.586 I slot print_timing: id  0 | task 247 |        eval time =     156.48 ms /     8 tokens (   19.56 ms per token,    51.12 tokens per second)",
+    "0.12.232.587 I slot print_timing: id  0 | task 247 |       total time =     223.92 ms /    13 tokens",
+    "0.12.232.587 I slot print_timing: id  0 | task 247 |    graphs reused =        162",
+    "0.12.232.600 I slot      release: id  0 | task 247 | stop processing: n_tokens = 12, truncated = 0",
+    "0.12.233.471 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47864060739",
+    "0.12.254.843 I slot launch_slot_: id  0 | task 257 | processing task, is_child = 0",
+    "0.12.448.527 I slot print_timing: id  0 | task 257 | prompt eval time =      39.68 ms /     3 tokens (   13.23 ms per token,    75.60 tokens per second)",
+    "0.12.448.534 I slot print_timing: id  0 | task 257 |        eval time =     153.98 ms /     8 tokens (   19.25 ms per token,    51.95 tokens per second)",
+    "0.12.448.535 I slot print_timing: id  0 | task 257 |       total time =     193.67 ms /    11 tokens",
+    "0.12.448.535 I slot print_timing: id  0 | task 257 |    graphs reused =        168",
+    "0.12.448.549 I slot      release: id  0 | task 257 | stop processing: n_tokens = 10, truncated = 0",
+    "0.12.449.528 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47864276687",
+    "0.12.470.868 I slot launch_slot_: id  0 | task 266 | processing task, is_child = 0",
+    "0.12.704.634 I slot print_timing: id  0 | task 266 | prompt eval time =      78.23 ms /     6 tokens (   13.04 ms per token,    76.69 tokens per second)",
+    "0.12.704.640 I slot print_timing: id  0 | task 266 |        eval time =     155.51 ms /     8 tokens (   19.44 ms per token,    51.44 tokens per second)",
+    "0.12.704.640 I slot print_timing: id  0 | task 266 |       total time =     233.74 ms /    14 tokens",
+    "0.12.704.641 I slot print_timing: id  0 | task 266 |    graphs reused =        174",
+    "0.12.704.654 I slot      release: id  0 | task 266 | stop processing: n_tokens = 13, truncated = 0",
+    "0.12.705.545 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47864532792",
+    "0.12.716.550 I slot launch_slot_: id  0 | task 276 | processing task, is_child = 0",
+    "0.12.917.068 I slot print_timing: id  0 | task 276 | prompt eval time =      40.03 ms /     3 tokens (   13.34 ms per token,    74.94 tokens per second)",
+    "0.12.917.073 I slot print_timing: id  0 | task 276 |        eval time =     160.47 ms /     8 tokens (   20.06 ms per token,    49.85 tokens per second)",
+    "0.12.917.073 I slot print_timing: id  0 | task 276 |       total time =     200.50 ms /    11 tokens",
+    "0.12.917.074 I slot print_timing: id  0 | task 276 |    graphs reused =        180",
+    "0.12.917.087 I slot      release: id  0 | task 276 | stop processing: n_tokens = 10, truncated = 0",
+    "0.12.918.062 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47864745225",
+    "0.12.923.872 I slot launch_slot_: id  0 | task 285 | processing task, is_child = 0",
+    "0.13.126.572 I slot print_timing: id  0 | task 285 | prompt eval time =      46.65 ms /     4 tokens (   11.66 ms per token,    85.74 tokens per second)",
+    "0.13.126.577 I slot print_timing: id  0 | task 285 |        eval time =     156.03 ms /     8 tokens (   19.50 ms per token,    51.27 tokens per second)",
+    "0.13.126.578 I slot print_timing: id  0 | task 285 |       total time =     202.69 ms /    12 tokens",
+    "0.13.126.579 I slot print_timing: id  0 | task 285 |    graphs reused =        186",
+    "0.13.126.592 I slot      release: id  0 | task 285 | stop processing: n_tokens = 11, truncated = 0",
+    "0.13.127.516 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47864954730",
+    "0.13.133.282 I slot launch_slot_: id  0 | task 294 | processing task, is_child = 0",
+    "0.13.373.978 I slot print_timing: id  0 | task 294 | prompt eval time =      83.33 ms /     7 tokens (   11.90 ms per token,    84.00 tokens per second)",
+    "0.13.373.983 I slot print_timing: id  0 | task 294 |        eval time =     157.35 ms /     8 tokens (   19.67 ms per token,    50.84 tokens per second)",
+    "0.13.373.983 I slot print_timing: id  0 | task 294 |       total time =     240.68 ms /    15 tokens",
+    "0.13.373.984 I slot print_timing: id  0 | task 294 |    graphs reused =        192",
+    "0.13.373.999 I slot      release: id  0 | task 294 | stop processing: n_tokens = 14, truncated = 0",
+    "0.13.374.883 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47865202137",
+    "0.13.382.188 I slot launch_slot_: id  0 | task 304 | processing task, is_child = 0",
+    "0.13.583.649 I slot print_timing: id  0 | task 304 | prompt eval time =      46.12 ms /     4 tokens (   11.53 ms per token,    86.72 tokens per second)",
+    "0.13.583.657 I slot print_timing: id  0 | task 304 |        eval time =     155.32 ms /     8 tokens (   19.42 ms per token,    51.51 tokens per second)",
+    "0.13.583.657 I slot print_timing: id  0 | task 304 |       total time =     201.45 ms /    12 tokens",
+    "0.13.583.658 I slot print_timing: id  0 | task 304 |    graphs reused =        198",
+    "0.13.583.692 I slot      release: id  0 | task 304 | stop processing: n_tokens = 11, truncated = 0",
+    "0.13.584.628 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47865411832",
+    "0.13.590.115 I slot launch_slot_: id  0 | task 313 | processing task, is_child = 0",
+    "0.13.883.903 I slot print_timing: id  0 | task 313 | prompt eval time =     136.72 ms /    14 tokens (    9.77 ms per token,   102.40 tokens per second)",
+    "0.13.883.908 I slot print_timing: id  0 | task 313 |        eval time =     157.05 ms /     8 tokens (   19.63 ms per token,    50.94 tokens per second)",
+    "0.13.883.909 I slot print_timing: id  0 | task 313 |       total time =     293.77 ms /    22 tokens",
+    "0.13.883.910 I slot print_timing: id  0 | task 313 |    graphs reused =        204",
+    "0.13.883.923 I slot      release: id  0 | task 313 | stop processing: n_tokens = 21, truncated = 0",
+    "0.13.885.025 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47865712061",
+    "0.13.892.381 I slot launch_slot_: id  0 | task 323 | processing task, is_child = 0",
+    "0.14.100.128 I slot print_timing: id  0 | task 323 | prompt eval time =      46.98 ms /     4 tokens (   11.74 ms per token,    85.15 tokens per second)",
+    "0.14.100.131 I slot print_timing: id  0 | task 323 |        eval time =     160.75 ms /     8 tokens (   20.09 ms per token,    49.77 tokens per second)",
+    "0.14.100.140 I slot print_timing: id  0 | task 323 |       total time =     207.73 ms /    12 tokens",
+    "0.14.100.140 I slot print_timing: id  0 | task 323 |    graphs reused =        210",
+    "0.14.100.150 I slot      release: id  0 | task 323 | stop processing: n_tokens = 11, truncated = 0",
+    "0.14.101.001 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 47865928288",
+    "0.14.106.361 I slot launch_slot_: id  0 | task 332 | processing task, is_child = 0",
+    "0.14.343.878 I slot print_timing: id  0 | task 332 | prompt eval time =      77.88 ms /     6 tokens (   12.98 ms per token,    77.04 tokens per second)",
+    "0.14.343.883 I slot print_timing: id  0 | task 332 |        eval time =     159.62 ms /     8 tokens (   19.95 ms per token,    50.12 tokens per second)",
+    "0.14.343.883 I slot print_timing: id  0 | task 332 |       total time =     237.50 ms /    14 tokens",
+    "0.14.343.884 I slot print_timing: id  0 | task 332 |    graphs reused =        216",
+    "0.14.343.895 I slot      release: id  0 | task 332 | stop processing: n_tokens = 13, truncated = 0",
+    "0.14.344.512 I srv    operator(): operator(): cleaning up before exit..."
+  ],
+  "measurement_complete": true,
+  "quality": {
+    "compared_tokens": 96,
+    "exact_position_fraction": 0.9791666666666666,
+    "exact_position_matches": 94,
+    "fully_identical_prompts": 11,
+    "interpretation": "Only tokens before the first divergence share an identical autoregressive context; later position matches are diagnostic, not an accuracy claim.",
+    "per_prompt": [
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "fully_identical": true,
+        "integer": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "hello_world"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "fully_identical": true,
+        "integer": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "paris"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          220,
+          19,
+          13,
+          271,
+          2,
+          220,
+          16,
+          13
+        ],
+        "fully_identical": true,
+        "integer": [
+          220,
+          19,
+          13,
+          271,
+          2,
+          220,
+          16,
+          13
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "arithmetic"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          220,
+          15,
+          29922,
+          321,
+          85895,
+          506,
+          220,
+          16
+        ],
+        "fully_identical": true,
+        "integer": [
+          220,
+          15,
+          29922,
+          321,
+          85895,
+          506,
+          220,
+          16
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "freezing"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          369,
+          264,
+          61446,
+          1560,
+          310,
+          1791,
+          11140,
+          3018
+        ],
+        "fully_identical": true,
+        "integer": [
+          369,
+          264,
+          61446,
+          1560,
+          310,
+          1791,
+          11140,
+          3018
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "python_comprehension"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          115197,
+          150553,
+          5205,
+          115197,
+          14876,
+          98823,
+          215293,
+          99605
+        ],
+        "fully_identical": true,
+        "integer": [
+          115197,
+          150553,
+          5205,
+          115197,
+          14876,
+          98823,
+          215293,
+          99605
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "japanese_capital"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 6,
+        "first_divergence_index": 6,
+        "fp": [
+          33075,
+          888,
+          279,
+          15217,
+          5388,
+          13,
+          271,
+          2
+        ],
+        "fully_identical": false,
+        "integer": [
+          33075,
+          888,
+          279,
+          15217,
+          5388,
+          13,
+          198,
+          760
+        ],
+        "prefix_match_tokens": 6,
+        "prompt": "quick_fox"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          271,
+          248068,
+          198,
+          90700,
+          8340,
+          25,
+          271,
+          16
+        ],
+        "fully_identical": true,
+        "integer": [
+          271,
+          248068,
+          198,
+          90700,
+          8340,
+          25,
+          271,
+          16
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "gravity"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          795,
+          19963,
+          321,
+          4779,
+          35479,
+          539,
+          59724,
+          7077
+        ],
+        "fully_identical": true,
+        "integer": [
+          795,
+          19963,
+          321,
+          4779,
+          35479,
+          539,
+          59724,
+          7077
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "rust_ownership"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          264,
+          33784,
+          278,
+          13,
+          271,
+          1919,
+          369,
+          264
+        ],
+        "fully_identical": true,
+        "integer": [
+          264,
+          33784,
+          278,
+          13,
+          271,
+          1919,
+          369,
+          264
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "logic_cat"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          198,
+          262,
+          413,
+          307,
+          2564,
+          220,
+          15,
+          25
+        ],
+        "fully_identical": true,
+        "integer": [
+          198,
+          262,
+          413,
+          307,
+          2564,
+          220,
+          15,
+          25
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "fibonacci"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          271,
+          248068,
+          198,
+          8160,
+          579,
+          264,
+          7047,
+          1817
+        ],
+        "fully_identical": true,
+        "integer": [
+          271,
+          248068,
+          198,
+          8160,
+          579,
+          264,
+          7047,
+          1817
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "french_translation"
+      }
+    ],
+    "prefix_match_fraction": 0.9791666666666666,
+    "prefix_match_tokens": 94,
+    "prompt_count": 12
+  },
+  "schema": "misaka.qi35.fp-calibration.v1",
+  "started_at_utc": "2026-07-21T03:42:54.858509Z"
+}
diff --git a/docs/evidence/reports/qi35-calibration-mac-20260721-v2.json b/docs/evidence/reports/qi35-calibration-mac-20260721-v2.json
new file mode 100644
index 0000000000000000000000000000000000000000..5e98ea0c8974d502186a660df26cecf95acb10c6
--- /dev/null
+++ b/docs/evidence/reports/qi35-calibration-mac-20260721-v2.json
@@ -0,0 +1,2064 @@
+{
+  "artifacts": {
+    "corpus": {
+      "basename": "qi35-calibration-prompts-v1.json",
+      "bytes": 1726,
+      "sha256": "7e05acc22fa58445b92ff8e9edf2466ea9eb107e76f43ae087449d7976b513bd"
+    },
+    "engine": {
+      "basename": "qi35_model",
+      "bytes": 818504,
+      "sha256": "48885e73492216cb7b1d5065d74e333099eaef065a92c0ff6602226eb2ff3abf"
+    },
+    "engine_libraries": [
+      {
+        "basename": "libqi35metal.dylib",
+        "bytes": 172976,
+        "sha256": "7ac3a1230840d0cbb29407a256e6c8e3fe6f8c2b0240e0a92dd705fa46e41f75"
+      }
+    ],
+    "engine_source": {
+      "basename": "qi35_model.rs",
+      "bytes": 100161,
+      "sha256": "098385055c5e1bc6a9cd6229a06a14be53e8403ea89d4f3ba9b53457c210eecd"
+    },
+    "llama_libraries": [
+      {
+        "basename": "libllama-server-impl.dylib",
+        "bytes": 3518936,
+        "sha256": "50270f32da282e10744ca576070111baf84a9b40fd6804c66533647344331f6f"
+      },
+      {
+        "basename": "libllama-common.0.0.10015.dylib",
+        "bytes": 4969832,
+        "sha256": "82f3f6f2f76d023d92849f9b21869130ed8c6618822dbdf2aa3067cdf9057bc4"
+      },
+      {
+        "basename": "libmtmd.0.0.10015.dylib",
+        "bytes": 1029920,
+        "sha256": "d7fa3d3459d9767fcd1007cdf9a981ea34347048659c802f252c26260c6bb4c8"
+      },
+      {
+        "basename": "libllama.0.0.10015.dylib",
+        "bytes": 2663088,
+        "sha256": "47a22694597b7b2e6004aafeb7eb364294b147713bc3ef6f8fc51208013f794b"
+      },
+      {
+        "basename": "libggml.0.16.0.dylib",
+        "bytes": 59808,
+        "sha256": "dbfdb8f69df9e05d54531d41fed4b950a41f67ad4cd0365b899776f3a824e4e1"
+      },
+      {
+        "basename": "libggml-base.0.16.0.dylib",
+        "bytes": 711208,
+        "sha256": "812c578136444f135b8a6b5f113ab012b8b48c27690e09058c326f7ff9b8be73"
+      },
+      {
+        "basename": "libggml-cpu.0.16.0.dylib",
+        "bytes": 934320,
+        "sha256": "172f0c200769b4373be3a8daed008e67cc6b974f3f73e4a5c1a9be31bba45c29"
+      },
+      {
+        "basename": "libggml-blas.0.16.0.dylib",
+        "bytes": 58776,
+        "sha256": "37fc972ce379db614b35f2f115f40358fb7934cc66b981444043087f371d34e2"
+      },
+      {
+        "basename": "libggml-metal.0.16.0.dylib",
+        "bytes": 849400,
+        "sha256": "7821024d78bc4152b6bcd871eeb6bc63207107709fe0c6afd3b6cf6e21677bf0"
+      }
+    ],
+    "llama_patch": {
+      "basename": "llama.cpp-palw-full.patch",
+      "bytes": 305392,
+      "sha256": "25f7062c3a930daf108a146f178c714c8978d92c83fa6d30af1f951705a8f62b"
+    },
+    "llama_server": {
+      "basename": "llama-server",
+      "bytes": 33472,
+      "sha256": "ad2946371ae4abe62115dc514dee11f4655ed117d718b714b338b00d82e039e0"
+    },
+    "model": {
+      "basename": "Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+      "bytes": 23938321728,
+      "sha256": "1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b"
+    },
+    "runner": {
+      "basename": "qi35_calibrate.py",
+      "bytes": 20692,
+      "sha256": "8ee83b038e58c3ebd943bf41a85caed6fa7015d2b73d36de33f3ac654871e252"
+    },
+    "soak_library": {
+      "basename": "qi35_soak.py",
+      "bytes": 38620,
+      "sha256": "977e8e39830d975c005864a5a2a5ebc2dc1c7300f8c829c21d5905c7a0e5fa7d"
+    },
+    "tables": {
+      "basename": "qi35_tables.bin",
+      "bytes": 4849688,
+      "sha256": "feb22fd1864a1396b9c2bc20937f3acad79bffefdefc71c50b3747da47b64c6e"
+    },
+    "tokenizer": {
+      "basename": "tokenizer.json",
+      "bytes": 19989343,
+      "sha256": "87a7830d63fcf43bf241c3c5242e96e62dd3fdc29224ca26fed8ea333db72de4"
+    }
+  },
+  "configuration": {
+    "context_size": 1024,
+    "engine_library_count": 1,
+    "iterations": 3,
+    "llama_gpu_layers": "all",
+    "llama_library_count": 9,
+    "llama_revision": "12127defda4f41b7679cb2477a4b0d65ee6a0c8f",
+    "llama_transport": "runner-owned numeric-loopback HTTP; proxies and redirects disabled",
+    "max_new": 8,
+    "prompts": [
+      {
+        "ids": [
+          9419,
+          11,
+          1814
+        ],
+        "name": "hello_world",
+        "text": "Hello, world"
+      },
+      {
+        "ids": [
+          760,
+          6511,
+          314,
+          9338,
+          369
+        ],
+        "name": "paris",
+        "text": "The capital of France is"
+      },
+      {
+        "ids": [
+          17,
+          478,
+          220,
+          17,
+          283
+        ],
+        "name": "arithmetic",
+        "text": "2 + 2 ="
+      },
+      {
+        "ids": [
+          27336,
+          90162,
+          506
+        ],
+        "name": "freezing",
+        "text": "Water freezes at"
+      },
+      {
+        "ids": [
+          623,
+          12654,
+          11,
+          264,
+          1103,
+          59036
+        ],
+        "name": "python_comprehension",
+        "text": "In Python, a list comprehension"
+      },
+      {
+        "ids": [
+          161607,
+          110161,
+          14876
+        ],
+        "name": "japanese_capital",
+        "text": "\u65e5\u672c\u306e\u9996\u90fd\u306f"
+      },
+      {
+        "ids": [
+          760,
+          3841,
+          13477,
+          37550
+        ],
+        "name": "quick_fox",
+        "text": "The quick brown fox"
+      },
+      {
+        "ids": [
+          814,
+          20139,
+          22525,
+          303,
+          799,
+          11316,
+          25
+        ],
+        "name": "gravity",
+        "text": "Explain gravity in one sentence:"
+      },
+      {
+        "ids": [
+          49,
+          575,
+          14834,
+          27028
+        ],
+        "name": "rust_ownership",
+        "text": "Rust ownership prevents"
+      },
+      {
+        "ids": [
+          2592,
+          660,
+          18833,
+          513,
+          53702,
+          321,
+          48130,
+          369,
+          264,
+          7993,
+          11,
+          1179,
+          48130,
+          369
+        ],
+        "name": "logic_cat",
+        "text": "If all cats are mammals and Luna is a cat, then Luna is"
+      },
+      {
+        "ids": [
+          727,
+          73111,
+          1393,
+          1590
+        ],
+        "name": "fibonacci",
+        "text": "def fibonacci(n):"
+      },
+      {
+        "ids": [
+          26583,
+          1603,
+          6353,
+          310,
+          8323,
+          25
+        ],
+        "name": "french_translation",
+        "text": "Translate good morning to French:"
+      }
+    ],
+    "sampling": {
+      "cache_prompt": false,
+      "dry_multiplier": 0.0,
+      "frequency_penalty": 0.0,
+      "ignore_eos": true,
+      "min_p": 0.0,
+      "presence_penalty": 0.0,
+      "raw_token_input_output": true,
+      "repeat_penalty": 1.0,
+      "temperature": 0.0,
+      "top_k": 0,
+      "top_p": 1.0
+    },
+    "threads": 8
+  },
+  "failures": [],
+  "finished_at_utc": "2026-07-21T04:58:41.237834Z",
+  "fp_measurements": [
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 0,
+      "predicted_ms": 142.774,
+      "predicted_per_second": 56.032610979590125,
+      "prompt": "hello_world",
+      "prompt_ms": 42.458,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 0,
+      "predicted_ms": 137.13,
+      "predicted_per_second": 58.33880259607672,
+      "prompt": "paris",
+      "prompt_ms": 64.178,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 0,
+      "predicted_ms": 144.403,
+      "predicted_per_second": 55.40051106971462,
+      "prompt": "arithmetic",
+      "prompt_ms": 64.816,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 0,
+      "predicted_ms": 142.37,
+      "predicted_per_second": 56.1916134016998,
+      "prompt": "freezing",
+      "prompt_ms": 38.375,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 0,
+      "predicted_ms": 140.367,
+      "predicted_per_second": 56.993452877100744,
+      "prompt": "python_comprehension",
+      "prompt_ms": 72.072,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 0,
+      "predicted_ms": 143.816,
+      "predicted_per_second": 55.6266340323747,
+      "prompt": "japanese_capital",
+      "prompt_ms": 41.863,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        271,
+        2
+      ],
+      "iteration": 0,
+      "predicted_ms": 142.311,
+      "predicted_per_second": 56.214909599398496,
+      "prompt": "quick_fox",
+      "prompt_ms": 43.389,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 0,
+      "predicted_ms": 139.937,
+      "predicted_per_second": 57.168583005209484,
+      "prompt": "gravity",
+      "prompt_ms": 82.521,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 0,
+      "predicted_ms": 141.279,
+      "predicted_per_second": 56.62554236652298,
+      "prompt": "rust_ownership",
+      "prompt_ms": 46.609,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 0,
+      "predicted_ms": 140.862,
+      "predicted_per_second": 56.793173460550044,
+      "prompt": "logic_cat",
+      "prompt_ms": 132.852,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 0,
+      "predicted_ms": 140.88,
+      "predicted_per_second": 56.78591709256105,
+      "prompt": "fibonacci",
+      "prompt_ms": 45.123,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 0,
+      "predicted_ms": 140.994,
+      "predicted_per_second": 56.74000312070017,
+      "prompt": "french_translation",
+      "prompt_ms": 74.623,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 1,
+      "predicted_ms": 142.001,
+      "predicted_per_second": 56.33763142513081,
+      "prompt": "hello_world",
+      "prompt_ms": 41.615,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 1,
+      "predicted_ms": 141.821,
+      "predicted_per_second": 56.409135459487665,
+      "prompt": "paris",
+      "prompt_ms": 64.367,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 1,
+      "predicted_ms": 142.416,
+      "predicted_per_second": 56.17346365576902,
+      "prompt": "arithmetic",
+      "prompt_ms": 79.549,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 1,
+      "predicted_ms": 141.993,
+      "predicted_per_second": 56.340805532667105,
+      "prompt": "freezing",
+      "prompt_ms": 38.207,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 1,
+      "predicted_ms": 142.314,
+      "predicted_per_second": 56.21372458085642,
+      "prompt": "python_comprehension",
+      "prompt_ms": 72.428,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 1,
+      "predicted_ms": 142.151,
+      "predicted_per_second": 56.27818305885994,
+      "prompt": "japanese_capital",
+      "prompt_ms": 39.602,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        271,
+        2
+      ],
+      "iteration": 1,
+      "predicted_ms": 142.232,
+      "predicted_per_second": 56.246133078350866,
+      "prompt": "quick_fox",
+      "prompt_ms": 43.411,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 1,
+      "predicted_ms": 142.001,
+      "predicted_per_second": 56.33763142513081,
+      "prompt": "gravity",
+      "prompt_ms": 79.292,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 1,
+      "predicted_ms": 141.362,
+      "predicted_per_second": 56.592294959041325,
+      "prompt": "rust_ownership",
+      "prompt_ms": 43.423,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 1,
+      "predicted_ms": 137.709,
+      "predicted_per_second": 58.09351603744127,
+      "prompt": "logic_cat",
+      "prompt_ms": 125.29,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 1,
+      "predicted_ms": 137.409,
+      "predicted_per_second": 58.22034946764769,
+      "prompt": "fibonacci",
+      "prompt_ms": 44.936,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 1,
+      "predicted_ms": 136.756,
+      "predicted_per_second": 58.49834742168534,
+      "prompt": "french_translation",
+      "prompt_ms": 70.482,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 2,
+      "predicted_ms": 136.987,
+      "predicted_per_second": 58.39970216151898,
+      "prompt": "hello_world",
+      "prompt_ms": 37.141,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 2,
+      "predicted_ms": 144.847,
+      "predicted_per_second": 55.230691695375114,
+      "prompt": "paris",
+      "prompt_ms": 63.471,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 2,
+      "predicted_ms": 138.318,
+      "predicted_per_second": 57.837736231003916,
+      "prompt": "arithmetic",
+      "prompt_ms": 64.39,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 2,
+      "predicted_ms": 140.486,
+      "predicted_per_second": 56.94517603177541,
+      "prompt": "freezing",
+      "prompt_ms": 37.016,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 2,
+      "predicted_ms": 142.886,
+      "predicted_per_second": 55.98869028456252,
+      "prompt": "python_comprehension",
+      "prompt_ms": 72.966,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 2,
+      "predicted_ms": 142.132,
+      "predicted_per_second": 56.2857062448991,
+      "prompt": "japanese_capital",
+      "prompt_ms": 38.141,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        271,
+        2
+      ],
+      "iteration": 2,
+      "predicted_ms": 141.995,
+      "predicted_per_second": 56.34001197225254,
+      "prompt": "quick_fox",
+      "prompt_ms": 42.206,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 2,
+      "predicted_ms": 141.151,
+      "predicted_per_second": 56.67689212262045,
+      "prompt": "gravity",
+      "prompt_ms": 80.105,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 2,
+      "predicted_ms": 142.321,
+      "predicted_per_second": 56.21095973187372,
+      "prompt": "rust_ownership",
+      "prompt_ms": 43.253,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 2,
+      "predicted_ms": 142.289,
+      "predicted_per_second": 56.22360126221985,
+      "prompt": "logic_cat",
+      "prompt_ms": 127.009,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 2,
+      "predicted_ms": 141.721,
+      "predicted_per_second": 56.44893840715208,
+      "prompt": "fibonacci",
+      "prompt_ms": 43.439,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 2,
+      "predicted_ms": 142.141,
+      "predicted_per_second": 56.282142379749686,
+      "prompt": "french_translation",
+      "prompt_ms": 71.647,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    }
+  ],
+  "host": {
+    "hw.memsize": "34359738368",
+    "hw.model": "Mac13,1",
+    "machdep.cpu.brand_string": "Apple M1 Max",
+    "machine": "arm64",
+    "python": "3.14.4",
+    "release": "25.5.0",
+    "system": "Darwin"
+  },
+  "integer_measurements": [
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 0,
+      "prompt": "hello_world",
+      "seconds": 8.58,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 0,
+      "prompt": "paris",
+      "seconds": 3.34,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 0,
+      "prompt": "arithmetic",
+      "seconds": 3.33,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 0,
+      "prompt": "freezing",
+      "seconds": 2.84,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 0,
+      "prompt": "python_comprehension",
+      "seconds": 3.58,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 0,
+      "prompt": "japanese_capital",
+      "seconds": 2.83,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 0,
+      "prompt": "quick_fox",
+      "seconds": 3.08,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 0,
+      "prompt": "gravity",
+      "seconds": 3.83,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 0,
+      "prompt": "rust_ownership",
+      "seconds": 3.09,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 0,
+      "prompt": "logic_cat",
+      "seconds": 5.54,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 0,
+      "prompt": "fibonacci",
+      "seconds": 3.08,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 0,
+      "prompt": "french_translation",
+      "seconds": 3.59,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 1,
+      "prompt": "hello_world",
+      "seconds": 2.84,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 1,
+      "prompt": "paris",
+      "seconds": 3.33,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 1,
+      "prompt": "arithmetic",
+      "seconds": 3.33,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 1,
+      "prompt": "freezing",
+      "seconds": 2.84,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 1,
+      "prompt": "python_comprehension",
+      "seconds": 3.59,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 1,
+      "prompt": "japanese_capital",
+      "seconds": 2.84,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 1,
+      "prompt": "quick_fox",
+      "seconds": 3.08,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 1,
+      "prompt": "gravity",
+      "seconds": 3.83,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 1,
+      "prompt": "rust_ownership",
+      "seconds": 3.09,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 1,
+      "prompt": "logic_cat",
+      "seconds": 5.53,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 1,
+      "prompt": "fibonacci",
+      "seconds": 3.08,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 1,
+      "prompt": "french_translation",
+      "seconds": 3.58,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 2,
+      "prompt": "hello_world",
+      "seconds": 2.84,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 2,
+      "prompt": "paris",
+      "seconds": 3.33,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 2,
+      "prompt": "arithmetic",
+      "seconds": 3.31,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 2,
+      "prompt": "freezing",
+      "seconds": 2.89,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 2,
+      "prompt": "python_comprehension",
+      "seconds": 3.57,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 2,
+      "prompt": "japanese_capital",
+      "seconds": 2.83,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 2,
+      "prompt": "quick_fox",
+      "seconds": 3.08,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 2,
+      "prompt": "gravity",
+      "seconds": 3.83,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 2,
+      "prompt": "rust_ownership",
+      "seconds": 3.09,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 2,
+      "prompt": "logic_cat",
+      "seconds": 5.55,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 2,
+      "prompt": "fibonacci",
+      "seconds": 3.08,
+      "tokens": 8
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 2,
+      "prompt": "french_translation",
+      "seconds": 3.58,
+      "tokens": 8
+    }
+  ],
+  "integer_stderr_tail": [
+    "qi35metal: maxBufferLength=20100448256",
+    "metal offload: ON",
+    "metal v3 (moe+deltanet+attention on-device): ON (kv bind0 1024 rows/layer)",
+    "SERVE_READY backend=rust-cpu-aarch64 receipts=false"
+  ],
+  "llama_log_tail": [
+    "0.05.861.263 I slot print_timing: id  0 | task 123 | prompt eval time =      64.37 ms /     5 tokens (   12.87 ms per token,    77.68 tokens per second)",
+    "0.05.861.266 I slot print_timing: id  0 | task 123 |        eval time =     141.82 ms /     8 tokens (   17.73 ms per token,    56.41 tokens per second)",
+    "0.05.861.266 I slot print_timing: id  0 | task 123 |       total time =     206.19 ms /    13 tokens",
+    "0.05.861.267 I slot print_timing: id  0 | task 123 |    graphs reused =         84",
+    "0.05.861.292 I slot      release: id  0 | task 123 | stop processing: n_tokens = 12, truncated = 0",
+    "0.05.862.106 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52209470806",
+    "0.05.915.067 I slot launch_slot_: id  0 | task 133 | processing task, is_child = 0",
+    "0.06.137.050 I slot print_timing: id  0 | task 133 | prompt eval time =      79.55 ms /     5 tokens (   15.91 ms per token,    62.85 tokens per second)",
+    "0.06.137.053 I slot print_timing: id  0 | task 133 |        eval time =     142.42 ms /     8 tokens (   17.80 ms per token,    56.17 tokens per second)",
+    "0.06.137.054 I slot print_timing: id  0 | task 133 |       total time =     221.97 ms /    13 tokens",
+    "0.06.137.054 I slot print_timing: id  0 | task 133 |    graphs reused =         90",
+    "0.06.137.066 I slot      release: id  0 | task 133 | stop processing: n_tokens = 12, truncated = 0",
+    "0.06.138.009 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52209746580",
+    "0.06.162.181 I slot launch_slot_: id  0 | task 143 | processing task, is_child = 0",
+    "0.06.342.392 I slot print_timing: id  0 | task 143 | prompt eval time =      38.21 ms /     3 tokens (   12.74 ms per token,    78.52 tokens per second)",
+    "0.06.342.395 I slot print_timing: id  0 | task 143 |        eval time =     141.99 ms /     8 tokens (   17.75 ms per token,    56.34 tokens per second)",
+    "0.06.342.396 I slot print_timing: id  0 | task 143 |       total time =     180.20 ms /    11 tokens",
+    "0.06.342.408 I slot print_timing: id  0 | task 143 |    graphs reused =         96",
+    "0.06.342.437 I slot      release: id  0 | task 143 | stop processing: n_tokens = 10, truncated = 0",
+    "0.06.343.290 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52209951952",
+    "0.06.378.077 I slot launch_slot_: id  0 | task 152 | processing task, is_child = 0",
+    "0.06.592.833 I slot print_timing: id  0 | task 152 | prompt eval time =      72.43 ms /     6 tokens (   12.07 ms per token,    82.84 tokens per second)",
+    "0.06.592.835 I slot print_timing: id  0 | task 152 |        eval time =     142.31 ms /     8 tokens (   17.79 ms per token,    56.21 tokens per second)",
+    "0.06.592.836 I slot print_timing: id  0 | task 152 |       total time =     214.74 ms /    14 tokens",
+    "0.06.592.836 I slot print_timing: id  0 | task 152 |    graphs reused =        102",
+    "0.06.592.872 I slot      release: id  0 | task 152 | stop processing: n_tokens = 13, truncated = 0",
+    "0.06.593.710 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52210202386",
+    "0.06.635.098 I slot launch_slot_: id  0 | task 162 | processing task, is_child = 0",
+    "0.06.816.878 I slot print_timing: id  0 | task 162 | prompt eval time =      39.60 ms /     3 tokens (   13.20 ms per token,    75.75 tokens per second)",
+    "0.06.816.881 I slot print_timing: id  0 | task 162 |        eval time =     142.15 ms /     8 tokens (   17.77 ms per token,    56.28 tokens per second)",
+    "0.06.816.881 I slot print_timing: id  0 | task 162 |       total time =     181.75 ms /    11 tokens",
+    "0.06.816.882 I slot print_timing: id  0 | task 162 |    graphs reused =        108",
+    "0.06.816.902 I slot      release: id  0 | task 162 | stop processing: n_tokens = 10, truncated = 0",
+    "0.06.817.668 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52210426416",
+    "0.06.838.395 I slot launch_slot_: id  0 | task 171 | processing task, is_child = 0",
+    "0.07.024.053 I slot print_timing: id  0 | task 171 | prompt eval time =      43.41 ms /     4 tokens (   10.85 ms per token,    92.14 tokens per second)",
+    "0.07.024.056 I slot print_timing: id  0 | task 171 |        eval time =     142.23 ms /     8 tokens (   17.78 ms per token,    56.25 tokens per second)",
+    "0.07.024.056 I slot print_timing: id  0 | task 171 |       total time =     185.64 ms /    12 tokens",
+    "0.07.024.056 I slot print_timing: id  0 | task 171 |    graphs reused =        114",
+    "0.07.024.109 I slot      release: id  0 | task 171 | stop processing: n_tokens = 11, truncated = 0",
+    "0.07.024.849 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52210633624",
+    "0.07.046.511 I slot launch_slot_: id  0 | task 180 | processing task, is_child = 0",
+    "0.07.267.815 I slot print_timing: id  0 | task 180 | prompt eval time =      79.29 ms /     7 tokens (   11.33 ms per token,    88.28 tokens per second)",
+    "0.07.267.818 I slot print_timing: id  0 | task 180 |        eval time =     142.00 ms /     8 tokens (   17.75 ms per token,    56.34 tokens per second)",
+    "0.07.267.818 I slot print_timing: id  0 | task 180 |       total time =     221.29 ms /    15 tokens",
+    "0.07.267.818 I slot print_timing: id  0 | task 180 |    graphs reused =        120",
+    "0.07.267.845 I slot      release: id  0 | task 180 | stop processing: n_tokens = 14, truncated = 0",
+    "0.07.268.626 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52210877359",
+    "0.07.299.168 I slot launch_slot_: id  0 | task 190 | processing task, is_child = 0",
+    "0.07.483.976 I slot print_timing: id  0 | task 190 | prompt eval time =      43.42 ms /     4 tokens (   10.86 ms per token,    92.12 tokens per second)",
+    "0.07.483.979 I slot print_timing: id  0 | task 190 |        eval time =     141.36 ms /     8 tokens (   17.67 ms per token,    56.59 tokens per second)",
+    "0.07.483.980 I slot print_timing: id  0 | task 190 |       total time =     184.78 ms /    12 tokens",
+    "0.07.483.980 I slot print_timing: id  0 | task 190 |    graphs reused =        126",
+    "0.07.483.991 I slot      release: id  0 | task 190 | stop processing: n_tokens = 11, truncated = 0",
+    "0.07.485.055 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52211093505",
+    "0.07.491.566 I slot launch_slot_: id  0 | task 199 | processing task, is_child = 0",
+    "0.07.754.586 I slot print_timing: id  0 | task 199 | prompt eval time =     125.29 ms /    14 tokens (    8.95 ms per token,   111.74 tokens per second)",
+    "0.07.754.591 I slot print_timing: id  0 | task 199 |        eval time =     137.71 ms /     8 tokens (   17.21 ms per token,    58.09 tokens per second)",
+    "0.07.754.591 I slot print_timing: id  0 | task 199 |       total time =     263.00 ms /    22 tokens",
+    "0.07.754.592 I slot print_timing: id  0 | task 199 |    graphs reused =        132",
+    "0.07.754.703 I slot      release: id  0 | task 199 | stop processing: n_tokens = 21, truncated = 0",
+    "0.07.755.523 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52211364219",
+    "0.07.784.765 I slot launch_slot_: id  0 | task 209 | processing task, is_child = 0",
+    "0.07.967.126 I slot print_timing: id  0 | task 209 | prompt eval time =      44.94 ms /     4 tokens (   11.23 ms per token,    89.02 tokens per second)",
+    "0.07.967.130 I slot print_timing: id  0 | task 209 |        eval time =     137.41 ms /     8 tokens (   17.18 ms per token,    58.22 tokens per second)",
+    "0.07.967.131 I slot print_timing: id  0 | task 209 |       total time =     182.34 ms /    12 tokens",
+    "0.07.967.132 I slot print_timing: id  0 | task 209 |    graphs reused =        138",
+    "0.07.967.144 I slot      release: id  0 | task 209 | stop processing: n_tokens = 11, truncated = 0",
+    "0.07.968.113 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52211576658",
+    "0.07.974.712 I slot launch_slot_: id  0 | task 218 | processing task, is_child = 0",
+    "0.08.181.968 I slot print_timing: id  0 | task 218 | prompt eval time =      70.48 ms /     6 tokens (   11.75 ms per token,    85.13 tokens per second)",
+    "0.08.181.973 I slot print_timing: id  0 | task 218 |        eval time =     136.76 ms /     8 tokens (   17.09 ms per token,    58.50 tokens per second)",
+    "0.08.181.973 I slot print_timing: id  0 | task 218 |       total time =     207.24 ms /    14 tokens",
+    "0.08.181.974 I slot print_timing: id  0 | task 218 |    graphs reused =        144",
+    "0.08.181.989 I slot      release: id  0 | task 218 | stop processing: n_tokens = 13, truncated = 0",
+    "0.08.182.877 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52211791503",
+    "0.08.206.994 I slot launch_slot_: id  0 | task 228 | processing task, is_child = 0",
+    "0.08.381.142 I slot print_timing: id  0 | task 228 | prompt eval time =      37.14 ms /     3 tokens (   12.38 ms per token,    80.77 tokens per second)",
+    "0.08.381.146 I slot print_timing: id  0 | task 228 |        eval time =     136.99 ms /     8 tokens (   17.12 ms per token,    58.40 tokens per second)",
+    "0.08.381.147 I slot print_timing: id  0 | task 228 |       total time =     174.13 ms /    11 tokens",
+    "0.08.381.147 I slot print_timing: id  0 | task 228 |    graphs reused =        150",
+    "0.08.381.164 I slot      release: id  0 | task 228 | stop processing: n_tokens = 10, truncated = 0",
+    "0.08.381.870 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52211990678",
+    "0.08.385.450 I slot launch_slot_: id  0 | task 237 | processing task, is_child = 0",
+    "0.08.593.778 I slot print_timing: id  0 | task 237 | prompt eval time =      63.47 ms /     5 tokens (   12.69 ms per token,    78.78 tokens per second)",
+    "0.08.593.782 I slot print_timing: id  0 | task 237 |        eval time =     144.85 ms /     8 tokens (   18.11 ms per token,    55.23 tokens per second)",
+    "0.08.593.783 I slot print_timing: id  0 | task 237 |       total time =     208.32 ms /    13 tokens",
+    "0.08.593.784 I slot print_timing: id  0 | task 237 |    graphs reused =        156",
+    "0.08.593.794 I slot      release: id  0 | task 237 | stop processing: n_tokens = 12, truncated = 0",
+    "0.08.594.669 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52212203308",
+    "0.08.606.186 I slot launch_slot_: id  0 | task 247 | processing task, is_child = 0",
+    "0.08.808.912 I slot print_timing: id  0 | task 247 | prompt eval time =      64.39 ms /     5 tokens (   12.88 ms per token,    77.65 tokens per second)",
+    "0.08.808.916 I slot print_timing: id  0 | task 247 |        eval time =     138.32 ms /     8 tokens (   17.29 ms per token,    57.84 tokens per second)",
+    "0.08.808.916 I slot print_timing: id  0 | task 247 |       total time =     202.71 ms /    13 tokens",
+    "0.08.808.917 I slot print_timing: id  0 | task 247 |    graphs reused =        162",
+    "0.08.808.932 I slot      release: id  0 | task 247 | stop processing: n_tokens = 12, truncated = 0",
+    "0.08.809.841 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52212418446",
+    "0.08.816.978 I slot launch_slot_: id  0 | task 257 | processing task, is_child = 0",
+    "0.08.994.494 I slot print_timing: id  0 | task 257 | prompt eval time =      37.02 ms /     3 tokens (   12.34 ms per token,    81.05 tokens per second)",
+    "0.08.994.498 I slot print_timing: id  0 | task 257 |        eval time =     140.49 ms /     8 tokens (   17.56 ms per token,    56.95 tokens per second)",
+    "0.08.994.499 I slot print_timing: id  0 | task 257 |       total time =     177.50 ms /    11 tokens",
+    "0.08.994.499 I slot print_timing: id  0 | task 257 |    graphs reused =        168",
+    "0.08.994.510 I slot      release: id  0 | task 257 | stop processing: n_tokens = 10, truncated = 0",
+    "0.08.995.324 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52212604024",
+    "0.09.001.843 I slot launch_slot_: id  0 | task 266 | processing task, is_child = 0",
+    "0.09.217.705 I slot print_timing: id  0 | task 266 | prompt eval time =      72.97 ms /     6 tokens (   12.16 ms per token,    82.23 tokens per second)",
+    "0.09.217.707 I slot print_timing: id  0 | task 266 |        eval time =     142.89 ms /     8 tokens (   17.86 ms per token,    55.99 tokens per second)",
+    "0.09.217.708 I slot print_timing: id  0 | task 266 |       total time =     215.85 ms /    14 tokens",
+    "0.09.217.708 I slot print_timing: id  0 | task 266 |    graphs reused =        174",
+    "0.09.217.717 I slot      release: id  0 | task 266 | stop processing: n_tokens = 13, truncated = 0",
+    "0.09.218.504 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52212827231",
+    "0.09.224.857 I slot launch_slot_: id  0 | task 276 | processing task, is_child = 0",
+    "0.09.405.142 I slot print_timing: id  0 | task 276 | prompt eval time =      38.14 ms /     3 tokens (   12.71 ms per token,    78.66 tokens per second)",
+    "0.09.405.145 I slot print_timing: id  0 | task 276 |        eval time =     142.13 ms /     8 tokens (   17.77 ms per token,    56.29 tokens per second)",
+    "0.09.405.146 I slot print_timing: id  0 | task 276 |       total time =     180.27 ms /    11 tokens",
+    "0.09.405.146 I slot print_timing: id  0 | task 276 |    graphs reused =        180",
+    "0.09.405.154 I slot      release: id  0 | task 276 | stop processing: n_tokens = 10, truncated = 0",
+    "0.09.405.931 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52213014668",
+    "0.09.410.887 I slot launch_slot_: id  0 | task 285 | processing task, is_child = 0",
+    "0.09.595.097 I slot print_timing: id  0 | task 285 | prompt eval time =      42.21 ms /     4 tokens (   10.55 ms per token,    94.77 tokens per second)",
+    "0.09.595.100 I slot print_timing: id  0 | task 285 |        eval time =     142.00 ms /     8 tokens (   17.75 ms per token,    56.34 tokens per second)",
+    "0.09.595.101 I slot print_timing: id  0 | task 285 |       total time =     184.20 ms /    12 tokens",
+    "0.09.595.101 I slot print_timing: id  0 | task 285 |    graphs reused =        186",
+    "0.09.595.112 I slot      release: id  0 | task 285 | stop processing: n_tokens = 11, truncated = 0",
+    "0.09.595.870 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52213204626",
+    "0.09.600.797 I slot launch_slot_: id  0 | task 294 | processing task, is_child = 0",
+    "0.09.822.066 I slot print_timing: id  0 | task 294 | prompt eval time =      80.11 ms /     7 tokens (   11.44 ms per token,    87.39 tokens per second)",
+    "0.09.822.070 I slot print_timing: id  0 | task 294 |        eval time =     141.15 ms /     8 tokens (   17.64 ms per token,    56.68 tokens per second)",
+    "0.09.822.071 I slot print_timing: id  0 | task 294 |       total time =     221.26 ms /    15 tokens",
+    "0.09.822.071 I slot print_timing: id  0 | task 294 |    graphs reused =        192",
+    "0.09.822.080 I slot      release: id  0 | task 294 | stop processing: n_tokens = 14, truncated = 0",
+    "0.09.822.822 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52213431594",
+    "0.09.829.120 I slot launch_slot_: id  0 | task 304 | processing task, is_child = 0",
+    "0.10.014.706 I slot print_timing: id  0 | task 304 | prompt eval time =      43.25 ms /     4 tokens (   10.81 ms per token,    92.48 tokens per second)",
+    "0.10.014.709 I slot print_timing: id  0 | task 304 |        eval time =     142.32 ms /     8 tokens (   17.79 ms per token,    56.21 tokens per second)",
+    "0.10.014.709 I slot print_timing: id  0 | task 304 |       total time =     185.57 ms /    12 tokens",
+    "0.10.014.709 I slot print_timing: id  0 | task 304 |    graphs reused =        198",
+    "0.10.014.719 I slot      release: id  0 | task 304 | stop processing: n_tokens = 11, truncated = 0",
+    "0.10.015.553 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52213624233",
+    "0.10.020.556 I slot launch_slot_: id  0 | task 313 | processing task, is_child = 0",
+    "0.10.289.869 I slot print_timing: id  0 | task 313 | prompt eval time =     127.01 ms /    14 tokens (    9.07 ms per token,   110.23 tokens per second)",
+    "0.10.289.872 I slot print_timing: id  0 | task 313 |        eval time =     142.29 ms /     8 tokens (   17.79 ms per token,    56.22 tokens per second)",
+    "0.10.289.873 I slot print_timing: id  0 | task 313 |       total time =     269.30 ms /    22 tokens",
+    "0.10.289.873 I slot print_timing: id  0 | task 313 |    graphs reused =        204",
+    "0.10.289.884 I slot      release: id  0 | task 313 | stop processing: n_tokens = 21, truncated = 0",
+    "0.10.290.656 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52213899398",
+    "0.10.297.305 I slot launch_slot_: id  0 | task 323 | processing task, is_child = 0",
+    "0.10.482.475 I slot print_timing: id  0 | task 323 | prompt eval time =      43.44 ms /     4 tokens (   10.86 ms per token,    92.08 tokens per second)",
+    "0.10.482.478 I slot print_timing: id  0 | task 323 |        eval time =     141.72 ms /     8 tokens (   17.72 ms per token,    56.45 tokens per second)",
+    "0.10.482.478 I slot print_timing: id  0 | task 323 |       total time =     185.16 ms /    12 tokens",
+    "0.10.482.479 I slot print_timing: id  0 | task 323 |    graphs reused =        210",
+    "0.10.482.488 I slot      release: id  0 | task 323 | stop processing: n_tokens = 11, truncated = 0",
+    "0.10.483.282 I slot get_availabl: id  0 | task -1 | selected slot by LRU, t_last = 52214092002",
+    "0.10.488.202 I slot launch_slot_: id  0 | task 332 | processing task, is_child = 0",
+    "0.10.702.002 I slot print_timing: id  0 | task 332 | prompt eval time =      71.65 ms /     6 tokens (   11.94 ms per token,    83.74 tokens per second)",
+    "0.10.702.004 I slot print_timing: id  0 | task 332 |        eval time =     142.14 ms /     8 tokens (   17.77 ms per token,    56.28 tokens per second)",
+    "0.10.702.005 I slot print_timing: id  0 | task 332 |       total time =     213.79 ms /    14 tokens",
+    "0.10.702.005 I slot print_timing: id  0 | task 332 |    graphs reused =        216",
+    "0.10.702.013 I slot      release: id  0 | task 332 | stop processing: n_tokens = 13, truncated = 0",
+    "0.10.702.547 I srv    operator(): operator(): cleaning up before exit..."
+  ],
+  "measurement_complete": true,
+  "quality": {
+    "compared_tokens": 96,
+    "exact_position_fraction": 0.9791666666666666,
+    "exact_position_matches": 94,
+    "fully_identical_prompts": 11,
+    "interpretation": "Only tokens before the first divergence share an identical autoregressive context; later position matches are diagnostic, not an accuracy claim.",
+    "per_prompt": [
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "fully_identical": true,
+        "integer": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "hello_world"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "fully_identical": true,
+        "integer": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "paris"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          220,
+          19,
+          13,
+          271,
+          2,
+          220,
+          16,
+          13
+        ],
+        "fully_identical": true,
+        "integer": [
+          220,
+          19,
+          13,
+          271,
+          2,
+          220,
+          16,
+          13
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "arithmetic"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          220,
+          15,
+          29922,
+          321,
+          85895,
+          506,
+          220,
+          16
+        ],
+        "fully_identical": true,
+        "integer": [
+          220,
+          15,
+          29922,
+          321,
+          85895,
+          506,
+          220,
+          16
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "freezing"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          369,
+          264,
+          61446,
+          1560,
+          310,
+          1791,
+          11140,
+          3018
+        ],
+        "fully_identical": true,
+        "integer": [
+          369,
+          264,
+          61446,
+          1560,
+          310,
+          1791,
+          11140,
+          3018
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "python_comprehension"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          115197,
+          150553,
+          5205,
+          115197,
+          14876,
+          98823,
+          215293,
+          99605
+        ],
+        "fully_identical": true,
+        "integer": [
+          115197,
+          150553,
+          5205,
+          115197,
+          14876,
+          98823,
+          215293,
+          99605
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "japanese_capital"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 6,
+        "first_divergence_index": 6,
+        "fp": [
+          33075,
+          888,
+          279,
+          15217,
+          5388,
+          13,
+          271,
+          2
+        ],
+        "fully_identical": false,
+        "integer": [
+          33075,
+          888,
+          279,
+          15217,
+          5388,
+          13,
+          198,
+          760
+        ],
+        "prefix_match_tokens": 6,
+        "prompt": "quick_fox"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          271,
+          248068,
+          198,
+          90700,
+          8340,
+          25,
+          271,
+          16
+        ],
+        "fully_identical": true,
+        "integer": [
+          271,
+          248068,
+          198,
+          90700,
+          8340,
+          25,
+          271,
+          16
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "gravity"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          795,
+          19963,
+          321,
+          4779,
+          35479,
+          539,
+          59724,
+          7077
+        ],
+        "fully_identical": true,
+        "integer": [
+          795,
+          19963,
+          321,
+          4779,
+          35479,
+          539,
+          59724,
+          7077
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "rust_ownership"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          264,
+          33784,
+          278,
+          13,
+          271,
+          1919,
+          369,
+          264
+        ],
+        "fully_identical": true,
+        "integer": [
+          264,
+          33784,
+          278,
+          13,
+          271,
+          1919,
+          369,
+          264
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "logic_cat"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          198,
+          262,
+          413,
+          307,
+          2564,
+          220,
+          15,
+          25
+        ],
+        "fully_identical": true,
+        "integer": [
+          198,
+          262,
+          413,
+          307,
+          2564,
+          220,
+          15,
+          25
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "fibonacci"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          271,
+          248068,
+          198,
+          8160,
+          579,
+          264,
+          7047,
+          1817
+        ],
+        "fully_identical": true,
+        "integer": [
+          271,
+          248068,
+          198,
+          8160,
+          579,
+          264,
+          7047,
+          1817
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "french_translation"
+      }
+    ],
+    "prefix_match_fraction": 0.9791666666666666,
+    "prefix_match_tokens": 94,
+    "prompt_count": 12
+  },
+  "schema": "misaka.qi35.fp-calibration.v2",
+  "started_at_utc": "2026-07-21T04:56:08.757379Z"
+}
diff --git a/docs/evidence/reports/qi35-fp-probe-wsl-rtx4060ti-20260721-v2.json b/docs/evidence/reports/qi35-fp-probe-wsl-rtx4060ti-20260721-v2.json
new file mode 100644
index 0000000000000000000000000000000000000000..9884ec02bba6498c6c68679cd545696056b56318
--- /dev/null
+++ b/docs/evidence/reports/qi35-fp-probe-wsl-rtx4060ti-20260721-v2.json
@@ -0,0 +1,1436 @@
+{
+  "accelerators": [
+    {
+      "compute_cap": "8.9",
+      "driver_version": "610.62",
+      "memory.total": "8188",
+      "name": "NVIDIA GeForce RTX 4060 Ti"
+    }
+  ],
+  "artifacts": {
+    "calibration_library": {
+      "basename": "qi35_calibrate.py",
+      "bytes": 18255,
+      "sha256": "e49d01153996824ad8351c5bbc75b1136270c70005b60705bfb12aa2c44a5a1c"
+    },
+    "corpus": {
+      "basename": "qi35-calibration-prompts-v1.json",
+      "bytes": 1726,
+      "sha256": "7e05acc22fa58445b92ff8e9edf2466ea9eb107e76f43ae087449d7976b513bd"
+    },
+    "llama_patch": {
+      "basename": "llama.cpp-palw-full.patch",
+      "bytes": 305392,
+      "sha256": "25f7062c3a930daf108a146f178c714c8978d92c83fa6d30af1f951705a8f62b"
+    },
+    "model": {
+      "basename": "qwen36-35b-q4km.gguf",
+      "bytes": 23938321728,
+      "sha256": "1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b"
+    },
+    "reference_calibration": {
+      "basename": "qi35-calibration-mac-20260721-final.json",
+      "bytes": 54554,
+      "sha256": "ad4e42268691606217ddd2a355dec433e9f899fa0426260d1049c8cd3f4cf89c"
+    },
+    "runner": {
+      "basename": "qi35_fp_probe.py",
+      "bytes": 13021,
+      "sha256": "21cb7a54c79b82a7a220446f02866ed5037899d247a9274f56f40e1198855a4a"
+    },
+    "server_binary": {
+      "basename": "llama-server",
+      "bytes": 17920,
+      "sha256": "96e0a5024a36b0e1be07a89c93687e01222db76c62005b4c8b893b50677c6523"
+    },
+    "server_libraries": [
+      {
+        "basename": "libllama-server-impl.so",
+        "bytes": 7042320,
+        "sha256": "7343188e7ee905280d0cdf1e5174854dea9d8b03fb181e0c714e232541aa792f"
+      },
+      {
+        "basename": "libllama-common.so.0",
+        "bytes": 5957384,
+        "sha256": "e3f8449d15d053d0f3d60216e79b15d0e1161e57f282e32f04082bd28d801332"
+      },
+      {
+        "basename": "libmtmd.so.0",
+        "bytes": 1432176,
+        "sha256": "6140a8bd358f1d5292e491b057c290e86691b9fd2eb6f1a81a8c0f659b8a6988"
+      },
+      {
+        "basename": "libllama.so.0",
+        "bytes": 4121720,
+        "sha256": "71993fce88235ef4a7ab95b7d6d824fff24997312cae9cca636d82debf1ac200"
+      },
+      {
+        "basename": "libggml.so.0",
+        "bytes": 56016,
+        "sha256": "e7fec42f7a61faa5a070c94777edbf3a096b679cf4390e1dea7676f2f9024d89"
+      },
+      {
+        "basename": "libggml-base.so.0",
+        "bytes": 913832,
+        "sha256": "8fe45b635da3d69dff4980ea6bb558fecfac8c495f6208ab328d7aee7be8ae26"
+      },
+      {
+        "basename": "libggml-cpu.so.0",
+        "bytes": 1135432,
+        "sha256": "7ff647de57ee0d67e3a76c8aedfe74595fe73ffef2c306dd1d37f3b6240a336b"
+      },
+      {
+        "basename": "libggml-cuda.so.0",
+        "bytes": 63387424,
+        "sha256": "52eefb8d73bbdac9126c9285112d3ba2568353565fdd0cae726a4f4781c7e262"
+      },
+      {
+        "basename": "libcudart.so.13",
+        "bytes": 782080,
+        "sha256": "9f92e4c3f7e14d0fed69ef876a45d4255a2dc88cb552a673a90ce881c26282fe"
+      },
+      {
+        "basename": "libcublas.so.13",
+        "bytes": 55354008,
+        "sha256": "01dd70979e68625846e9a5edcba531d3798498b866aa1c925cc25d60f63fe680"
+      },
+      {
+        "basename": "libcublasLt.so.13",
+        "bytes": 516598272,
+        "sha256": "93c275af70b6d39fbd9b78cbc925ad9a9a0a81189aaec1521a951119ebe72da3"
+      },
+      {
+        "basename": "libcuda.so.1",
+        "bytes": 187984,
+        "sha256": "158e0c4e9427a5fbc34ebe07000505744adf115f3baf857dae87dcf1f0674732"
+      }
+    ],
+    "soak_library": {
+      "basename": "qi35_soak.py",
+      "bytes": 34889,
+      "sha256": "3c029e869f20474ad53a7abc21e1666b63616424022e504eb43cc522fa1787e3"
+    },
+    "tokenizer": {
+      "basename": "tokenizer.json",
+      "bytes": 19989343,
+      "sha256": "87a7830d63fcf43bf241c3c5242e96e62dd3fdc29224ca26fed8ea333db72de4"
+    }
+  },
+  "configuration": {
+    "iterations": 3,
+    "llama_revision": "12127defda4f41b7679cb2477a4b0d65ee6a0c8f",
+    "max_new": 8,
+    "prompts": [
+      {
+        "ids": [
+          9419,
+          11,
+          1814
+        ],
+        "name": "hello_world",
+        "text": "Hello, world"
+      },
+      {
+        "ids": [
+          760,
+          6511,
+          314,
+          9338,
+          369
+        ],
+        "name": "paris",
+        "text": "The capital of France is"
+      },
+      {
+        "ids": [
+          17,
+          478,
+          220,
+          17,
+          283
+        ],
+        "name": "arithmetic",
+        "text": "2 + 2 ="
+      },
+      {
+        "ids": [
+          27336,
+          90162,
+          506
+        ],
+        "name": "freezing",
+        "text": "Water freezes at"
+      },
+      {
+        "ids": [
+          623,
+          12654,
+          11,
+          264,
+          1103,
+          59036
+        ],
+        "name": "python_comprehension",
+        "text": "In Python, a list comprehension"
+      },
+      {
+        "ids": [
+          161607,
+          110161,
+          14876
+        ],
+        "name": "japanese_capital",
+        "text": "\u65e5\u672c\u306e\u9996\u90fd\u306f"
+      },
+      {
+        "ids": [
+          760,
+          3841,
+          13477,
+          37550
+        ],
+        "name": "quick_fox",
+        "text": "The quick brown fox"
+      },
+      {
+        "ids": [
+          814,
+          20139,
+          22525,
+          303,
+          799,
+          11316,
+          25
+        ],
+        "name": "gravity",
+        "text": "Explain gravity in one sentence:"
+      },
+      {
+        "ids": [
+          49,
+          575,
+          14834,
+          27028
+        ],
+        "name": "rust_ownership",
+        "text": "Rust ownership prevents"
+      },
+      {
+        "ids": [
+          2592,
+          660,
+          18833,
+          513,
+          53702,
+          321,
+          48130,
+          369,
+          264,
+          7993,
+          11,
+          1179,
+          48130,
+          369
+        ],
+        "name": "logic_cat",
+        "text": "If all cats are mammals and Luna is a cat, then Luna is"
+      },
+      {
+        "ids": [
+          727,
+          73111,
+          1393,
+          1590
+        ],
+        "name": "fibonacci",
+        "text": "def fibonacci(n):"
+      },
+      {
+        "ids": [
+          26583,
+          1603,
+          6353,
+          310,
+          8323,
+          25
+        ],
+        "name": "french_translation",
+        "text": "Translate good morning to French:"
+      }
+    ],
+    "sampling": {
+      "cache_prompt": false,
+      "dry_multiplier": 0.0,
+      "frequency_penalty": 0.0,
+      "ignore_eos": true,
+      "min_p": 0.0,
+      "presence_penalty": 0.0,
+      "raw_token_input_output": true,
+      "repeat_penalty": 1.0,
+      "temperature": 0.0,
+      "top_k": 0,
+      "top_p": 1.0
+    },
+    "server_library_count": 12,
+    "server_origin": "http://127.0.0.1:18081"
+  },
+  "failures": [],
+  "finished_at_utc": "2026-07-21T03:50:09.195877Z",
+  "fp_measurements": [
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 0,
+      "predicted_ms": 809.745,
+      "predicted_per_second": 9.8796534711545,
+      "prompt": "hello_world",
+      "prompt_ms": 1010.015,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 0,
+      "predicted_ms": 781.291,
+      "predicted_per_second": 10.23946263300102,
+      "prompt": "paris",
+      "prompt_ms": 799.194,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 0,
+      "predicted_ms": 734.799,
+      "predicted_per_second": 10.887331093264962,
+      "prompt": "arithmetic",
+      "prompt_ms": 877.116,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 0,
+      "predicted_ms": 737.619,
+      "predicted_per_second": 10.845707607857172,
+      "prompt": "freezing",
+      "prompt_ms": 201.016,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 0,
+      "predicted_ms": 727.001,
+      "predicted_per_second": 11.004111411125983,
+      "prompt": "python_comprehension",
+      "prompt_ms": 1021.642,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 0,
+      "predicted_ms": 716.824,
+      "predicted_per_second": 11.160340613595528,
+      "prompt": "japanese_capital",
+      "prompt_ms": 332.315,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 0,
+      "predicted_ms": 705.624,
+      "predicted_per_second": 11.337482852057185,
+      "prompt": "quick_fox",
+      "prompt_ms": 215.666,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 0,
+      "predicted_ms": 725.513,
+      "predicted_per_second": 11.026680431639406,
+      "prompt": "gravity",
+      "prompt_ms": 859.015,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 0,
+      "predicted_ms": 720.254,
+      "predicted_per_second": 11.107192740338824,
+      "prompt": "rust_ownership",
+      "prompt_ms": 231.736,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 0,
+      "predicted_ms": 735.519,
+      "predicted_per_second": 10.876673478183433,
+      "prompt": "logic_cat",
+      "prompt_ms": 635.865,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 0,
+      "predicted_ms": 722.679,
+      "predicted_per_second": 11.069921777165243,
+      "prompt": "fibonacci",
+      "prompt_ms": 231.355,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 0,
+      "predicted_ms": 724.434,
+      "predicted_per_second": 11.043103995671103,
+      "prompt": "french_translation",
+      "prompt_ms": 373.91,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 1,
+      "predicted_ms": 737.415,
+      "predicted_per_second": 10.84870798668321,
+      "prompt": "hello_world",
+      "prompt_ms": 190.604,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 1,
+      "predicted_ms": 728.923,
+      "predicted_per_second": 10.975096134982707,
+      "prompt": "paris",
+      "prompt_ms": 325.746,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 1,
+      "predicted_ms": 733.8,
+      "predicted_per_second": 10.902153175252113,
+      "prompt": "arithmetic",
+      "prompt_ms": 318.402,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 1,
+      "predicted_ms": 731.77,
+      "predicted_per_second": 10.932396791341542,
+      "prompt": "freezing",
+      "prompt_ms": 186.873,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 1,
+      "predicted_ms": 724.822,
+      "predicted_per_second": 11.037192579695429,
+      "prompt": "python_comprehension",
+      "prompt_ms": 366.147,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 1,
+      "predicted_ms": 715.229,
+      "predicted_per_second": 11.185228786864066,
+      "prompt": "japanese_capital",
+      "prompt_ms": 187.131,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 1,
+      "predicted_ms": 728.365,
+      "predicted_per_second": 10.983504149705162,
+      "prompt": "quick_fox",
+      "prompt_ms": 222.487,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 1,
+      "predicted_ms": 707.707,
+      "predicted_per_second": 11.304113142868447,
+      "prompt": "gravity",
+      "prompt_ms": 411.732,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 1,
+      "predicted_ms": 718.482,
+      "predicted_per_second": 11.134586531047404,
+      "prompt": "rust_ownership",
+      "prompt_ms": 215.283,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 1,
+      "predicted_ms": 717.07,
+      "predicted_per_second": 11.15651191654929,
+      "prompt": "logic_cat",
+      "prompt_ms": 551.218,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 1,
+      "predicted_ms": 711.427,
+      "predicted_per_second": 11.245004758042638,
+      "prompt": "fibonacci",
+      "prompt_ms": 225.735,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 1,
+      "predicted_ms": 718.148,
+      "predicted_per_second": 11.139765062354835,
+      "prompt": "french_translation",
+      "prompt_ms": 379.744,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 2,
+      "predicted_ms": 699.458,
+      "predicted_per_second": 11.437427265110987,
+      "prompt": "hello_world",
+      "prompt_ms": 184.897,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 2,
+      "predicted_ms": 693.285,
+      "predicted_per_second": 11.539265958444219,
+      "prompt": "paris",
+      "prompt_ms": 298.728,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 2,
+      "predicted_ms": 700.657,
+      "predicted_per_second": 11.417854956134027,
+      "prompt": "arithmetic",
+      "prompt_ms": 308.688,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 2,
+      "predicted_ms": 685.653,
+      "predicted_per_second": 11.667709468200387,
+      "prompt": "freezing",
+      "prompt_ms": 175.722,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 2,
+      "predicted_ms": 706.779,
+      "predicted_per_second": 11.318955430198125,
+      "prompt": "python_comprehension",
+      "prompt_ms": 348.503,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 2,
+      "predicted_ms": 693.361,
+      "predicted_per_second": 11.53800112783961,
+      "prompt": "japanese_capital",
+      "prompt_ms": 172.044,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 2,
+      "predicted_ms": 716.293,
+      "predicted_per_second": 11.168613961046667,
+      "prompt": "quick_fox",
+      "prompt_ms": 205.708,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 2,
+      "predicted_ms": 715.489,
+      "predicted_per_second": 11.181164210770536,
+      "prompt": "gravity",
+      "prompt_ms": 421.798,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 2,
+      "predicted_ms": 716.742,
+      "predicted_per_second": 11.16161742998178,
+      "prompt": "rust_ownership",
+      "prompt_ms": 225.694,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 2,
+      "predicted_ms": 720.97,
+      "predicted_per_second": 11.096162114928498,
+      "prompt": "logic_cat",
+      "prompt_ms": 514.511,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 2,
+      "predicted_ms": 721.202,
+      "predicted_per_second": 11.092592643947189,
+      "prompt": "fibonacci",
+      "prompt_ms": 211.154,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 2,
+      "predicted_ms": 717.038,
+      "predicted_per_second": 11.157009809800876,
+      "prompt": "french_translation",
+      "prompt_ms": 373.584,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    }
+  ],
+  "host": {
+    "machine": "x86_64",
+    "nvidia_gpus": [
+      "NVIDIA GeForce RTX 4060 Ti, 8.9, 610.62"
+    ],
+    "python": "3.12.3",
+    "release": "6.18.33.2-microsoft-standard-WSL2",
+    "system": "Linux"
+  },
+  "measurement_complete": true,
+  "quality": {
+    "compared_tokens": 96,
+    "exact_position_fraction": 1.0,
+    "exact_position_matches": 96,
+    "fully_identical_prompts": 12,
+    "interpretation": "Only tokens before the first divergence share an identical autoregressive context; later position matches are diagnostic, not an accuracy claim.",
+    "per_prompt": [
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "fully_identical": true,
+        "integer": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "hello_world"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "fully_identical": true,
+        "integer": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "paris"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          220,
+          19,
+          13,
+          271,
+          2,
+          220,
+          16,
+          13
+        ],
+        "fully_identical": true,
+        "integer": [
+          220,
+          19,
+          13,
+          271,
+          2,
+          220,
+          16,
+          13
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "arithmetic"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          220,
+          15,
+          29922,
+          321,
+          85895,
+          506,
+          220,
+          16
+        ],
+        "fully_identical": true,
+        "integer": [
+          220,
+          15,
+          29922,
+          321,
+          85895,
+          506,
+          220,
+          16
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "freezing"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          369,
+          264,
+          61446,
+          1560,
+          310,
+          1791,
+          11140,
+          3018
+        ],
+        "fully_identical": true,
+        "integer": [
+          369,
+          264,
+          61446,
+          1560,
+          310,
+          1791,
+          11140,
+          3018
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "python_comprehension"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          115197,
+          150553,
+          5205,
+          115197,
+          14876,
+          98823,
+          215293,
+          99605
+        ],
+        "fully_identical": true,
+        "integer": [
+          115197,
+          150553,
+          5205,
+          115197,
+          14876,
+          98823,
+          215293,
+          99605
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "japanese_capital"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          33075,
+          888,
+          279,
+          15217,
+          5388,
+          13,
+          198,
+          760
+        ],
+        "fully_identical": true,
+        "integer": [
+          33075,
+          888,
+          279,
+          15217,
+          5388,
+          13,
+          198,
+          760
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "quick_fox"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          271,
+          248068,
+          198,
+          90700,
+          8340,
+          25,
+          271,
+          16
+        ],
+        "fully_identical": true,
+        "integer": [
+          271,
+          248068,
+          198,
+          90700,
+          8340,
+          25,
+          271,
+          16
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "gravity"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          795,
+          19963,
+          321,
+          4779,
+          35479,
+          539,
+          59724,
+          7077
+        ],
+        "fully_identical": true,
+        "integer": [
+          795,
+          19963,
+          321,
+          4779,
+          35479,
+          539,
+          59724,
+          7077
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "rust_ownership"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          264,
+          33784,
+          278,
+          13,
+          271,
+          1919,
+          369,
+          264
+        ],
+        "fully_identical": true,
+        "integer": [
+          264,
+          33784,
+          278,
+          13,
+          271,
+          1919,
+          369,
+          264
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "logic_cat"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          198,
+          262,
+          413,
+          307,
+          2564,
+          220,
+          15,
+          25
+        ],
+        "fully_identical": true,
+        "integer": [
+          198,
+          262,
+          413,
+          307,
+          2564,
+          220,
+          15,
+          25
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "fibonacci"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          271,
+          248068,
+          198,
+          8160,
+          579,
+          264,
+          7047,
+          1817
+        ],
+        "fully_identical": true,
+        "integer": [
+          271,
+          248068,
+          198,
+          8160,
+          579,
+          264,
+          7047,
+          1817
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "french_translation"
+      }
+    ],
+    "prefix_match_fraction": 1.0,
+    "prefix_match_tokens": 96,
+    "prompt_count": 12
+  },
+  "reference": {
+    "artifacts": {
+      "corpus": {
+        "basename": "qi35-calibration-prompts-v1.json",
+        "bytes": 1726,
+        "sha256": "7e05acc22fa58445b92ff8e9edf2466ea9eb107e76f43ae087449d7976b513bd"
+      },
+      "engine": {
+        "basename": "qi35_model-portable-mac",
+        "bytes": 818520,
+        "sha256": "242a3614eea9e129e0ef9a48c5f8ca320c3b6eb4c616e82c50fdc4f6de631660"
+      },
+      "engine_source": {
+        "basename": "qi35_model.rs",
+        "bytes": 100161,
+        "sha256": "098385055c5e1bc6a9cd6229a06a14be53e8403ea89d4f3ba9b53457c210eecd"
+      },
+      "llama_libraries": [
+        {
+          "basename": "libllama-server-impl.dylib",
+          "bytes": 3518936,
+          "sha256": "50270f32da282e10744ca576070111baf84a9b40fd6804c66533647344331f6f"
+        },
+        {
+          "basename": "libllama-common.0.0.10015.dylib",
+          "bytes": 4969832,
+          "sha256": "82f3f6f2f76d023d92849f9b21869130ed8c6618822dbdf2aa3067cdf9057bc4"
+        },
+        {
+          "basename": "libmtmd.0.0.10015.dylib",
+          "bytes": 1029920,
+          "sha256": "d7fa3d3459d9767fcd1007cdf9a981ea34347048659c802f252c26260c6bb4c8"
+        },
+        {
+          "basename": "libllama.0.0.10015.dylib",
+          "bytes": 2663088,
+          "sha256": "47a22694597b7b2e6004aafeb7eb364294b147713bc3ef6f8fc51208013f794b"
+        },
+        {
+          "basename": "libggml.0.16.0.dylib",
+          "bytes": 59808,
+          "sha256": "dbfdb8f69df9e05d54531d41fed4b950a41f67ad4cd0365b899776f3a824e4e1"
+        },
+        {
+          "basename": "libggml-cpu.0.16.0.dylib",
+          "bytes": 934320,
+          "sha256": "172f0c200769b4373be3a8daed008e67cc6b974f3f73e4a5c1a9be31bba45c29"
+        },
+        {
+          "basename": "libggml-blas.0.16.0.dylib",
+          "bytes": 58776,
+          "sha256": "37fc972ce379db614b35f2f115f40358fb7934cc66b981444043087f371d34e2"
+        },
+        {
+          "basename": "libggml-metal.0.16.0.dylib",
+          "bytes": 849400,
+          "sha256": "7821024d78bc4152b6bcd871eeb6bc63207107709fe0c6afd3b6cf6e21677bf0"
+        },
+        {
+          "basename": "libggml-base.0.16.0.dylib",
+          "bytes": 711208,
+          "sha256": "812c578136444f135b8a6b5f113ab012b8b48c27690e09058c326f7ff9b8be73"
+        }
+      ],
+      "llama_patch": {
+        "basename": "llama.cpp-palw-full.patch",
+        "bytes": 305392,
+        "sha256": "25f7062c3a930daf108a146f178c714c8978d92c83fa6d30af1f951705a8f62b"
+      },
+      "llama_server": {
+        "basename": "llama-server",
+        "bytes": 33472,
+        "sha256": "ad2946371ae4abe62115dc514dee11f4655ed117d718b714b338b00d82e039e0"
+      },
+      "model": {
+        "basename": "Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+        "bytes": 23938321728,
+        "sha256": "1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b"
+      },
+      "runner": {
+        "basename": "qi35_calibrate.py",
+        "bytes": 18255,
+        "sha256": "e49d01153996824ad8351c5bbc75b1136270c70005b60705bfb12aa2c44a5a1c"
+      },
+      "soak_library": {
+        "basename": "qi35_soak.py",
+        "bytes": 34889,
+        "sha256": "3c029e869f20474ad53a7abc21e1666b63616424022e504eb43cc522fa1787e3"
+      },
+      "tables": {
+        "basename": "qi35_tables.bin",
+        "bytes": 4849688,
+        "sha256": "feb22fd1864a1396b9c2bc20937f3acad79bffefdefc71c50b3747da47b64c6e"
+      },
+      "tokenizer": {
+        "basename": "tokenizer.json",
+        "bytes": 19989343,
+        "sha256": "87a7830d63fcf43bf241c3c5242e96e62dd3fdc29224ca26fed8ea333db72de4"
+      }
+    },
+    "host": {
+      "hw.memsize": "34359738368",
+      "hw.model": "Mac13,1",
+      "machdep.cpu.brand_string": "Apple M1 Max",
+      "machine": "arm64",
+      "python": "3.14.4",
+      "release": "25.5.0",
+      "system": "Darwin"
+    }
+  },
+  "schema": "misaka.qi35.fp-cross-host-probe.v1",
+  "scope": "Cross-host floating-point CUDA calibration only; this does not claim a canonical-integer CUDA backend.",
+  "started_at_utc": "2026-07-21T03:49:00.979645Z"
+}
diff --git a/docs/evidence/reports/qi35-fp-probe-wsl-rtx4060ti-20260721-v3.json b/docs/evidence/reports/qi35-fp-probe-wsl-rtx4060ti-20260721-v3.json
new file mode 100644
index 0000000000000000000000000000000000000000..1a8ad516387145871277a23b13954f5b2934b4a5
--- /dev/null
+++ b/docs/evidence/reports/qi35-fp-probe-wsl-rtx4060ti-20260721-v3.json
@@ -0,0 +1,1650 @@
+{
+  "accelerators": [
+    {
+      "compute_cap": "8.9",
+      "driver_version": "610.62",
+      "memory.total": "8188",
+      "name": "NVIDIA GeForce RTX 4060 Ti"
+    }
+  ],
+  "artifacts": {
+    "calibration_library": {
+      "basename": "qi35_calibrate.py",
+      "bytes": 20692,
+      "sha256": "8ee83b038e58c3ebd943bf41a85caed6fa7015d2b73d36de33f3ac654871e252"
+    },
+    "corpus": {
+      "basename": "qi35-calibration-prompts-v1.json",
+      "bytes": 1726,
+      "sha256": "7e05acc22fa58445b92ff8e9edf2466ea9eb107e76f43ae087449d7976b513bd"
+    },
+    "llama_patch": {
+      "basename": "llama.cpp-palw-full.patch",
+      "bytes": 305392,
+      "sha256": "25f7062c3a930daf108a146f178c714c8978d92c83fa6d30af1f951705a8f62b"
+    },
+    "model": {
+      "basename": "Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+      "bytes": 23938321728,
+      "sha256": "1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b"
+    },
+    "nvidia_smi": {
+      "basename": "nvidia-smi",
+      "bytes": 859968,
+      "sha256": "9619d52cbaf7e0ce80ea084cafad0a01b24ffc472172409a127854fb42d2b0a3"
+    },
+    "reference_calibration": {
+      "basename": "qi35-calibration-mac-20260721-v2.json",
+      "bytes": 54875,
+      "sha256": "521f1c67742ba88583f7c92b956a484e828b7643880c880d8f3a710c7ee27140"
+    },
+    "runner": {
+      "basename": "qi35_fp_probe.py",
+      "bytes": 34952,
+      "sha256": "c65cb00747d9d2ccf16b698ed12840e6b600850427a42100657886d1d14b2079"
+    },
+    "server_binary": {
+      "basename": "llama-server",
+      "bytes": 17920,
+      "sha256": "96e0a5024a36b0e1be07a89c93687e01222db76c62005b4c8b893b50677c6523"
+    },
+    "server_libraries": [
+      {
+        "basename": "libllama-server-impl.so",
+        "bytes": 7042320,
+        "sha256": "7343188e7ee905280d0cdf1e5174854dea9d8b03fb181e0c714e232541aa792f"
+      },
+      {
+        "basename": "libllama-common.so.0.0.10015",
+        "bytes": 5957384,
+        "sha256": "e3f8449d15d053d0f3d60216e79b15d0e1161e57f282e32f04082bd28d801332"
+      },
+      {
+        "basename": "libmtmd.so.0.0.10015",
+        "bytes": 1432176,
+        "sha256": "6140a8bd358f1d5292e491b057c290e86691b9fd2eb6f1a81a8c0f659b8a6988"
+      },
+      {
+        "basename": "libllama.so.0.0.10015",
+        "bytes": 4121720,
+        "sha256": "71993fce88235ef4a7ab95b7d6d824fff24997312cae9cca636d82debf1ac200"
+      },
+      {
+        "basename": "libggml.so.0.16.0",
+        "bytes": 56016,
+        "sha256": "e7fec42f7a61faa5a070c94777edbf3a096b679cf4390e1dea7676f2f9024d89"
+      },
+      {
+        "basename": "libggml-base.so.0.16.0",
+        "bytes": 913832,
+        "sha256": "8fe45b635da3d69dff4980ea6bb558fecfac8c495f6208ab328d7aee7be8ae26"
+      },
+      {
+        "basename": "libggml-cpu.so.0.16.0",
+        "bytes": 1135432,
+        "sha256": "7ff647de57ee0d67e3a76c8aedfe74595fe73ffef2c306dd1d37f3b6240a336b"
+      },
+      {
+        "basename": "libggml-cuda.so.0.16.0",
+        "bytes": 63387424,
+        "sha256": "52eefb8d73bbdac9126c9285112d3ba2568353565fdd0cae726a4f4781c7e262"
+      },
+      {
+        "basename": "libcudart.so.13.3.29",
+        "bytes": 782080,
+        "sha256": "9f92e4c3f7e14d0fed69ef876a45d4255a2dc88cb552a673a90ce881c26282fe"
+      },
+      {
+        "basename": "libcublas.so.13.6.0.2",
+        "bytes": 55354008,
+        "sha256": "01dd70979e68625846e9a5edcba531d3798498b866aa1c925cc25d60f63fe680"
+      },
+      {
+        "basename": "libcublasLt.so.13.6.0.2",
+        "bytes": 516598272,
+        "sha256": "93c275af70b6d39fbd9b78cbc925ad9a9a0a81189aaec1521a951119ebe72da3"
+      },
+      {
+        "basename": "libcuda.so.1.1",
+        "bytes": 187984,
+        "sha256": "158e0c4e9427a5fbc34ebe07000505744adf115f3baf857dae87dcf1f0674732"
+      },
+      {
+        "basename": "libcuda.so.1.1",
+        "bytes": 27803920,
+        "sha256": "97ba7b6097a38febf9e40ac0c27da10bdc717efdad498a4870aa783b058d7ace"
+      }
+    ],
+    "soak_library": {
+      "basename": "qi35_soak.py",
+      "bytes": 38620,
+      "sha256": "977e8e39830d975c005864a5a2a5ebc2dc1c7300f8c829c21d5905c7a0e5fa7d"
+    },
+    "tokenizer": {
+      "basename": "tokenizer.json",
+      "bytes": 19989343,
+      "sha256": "87a7830d63fcf43bf241c3c5242e96e62dd3fdc29224ca26fed8ea333db72de4"
+    }
+  },
+  "configuration": {
+    "accelerator_inventory": "explicit content-addressed nvidia-smi; inherited environment scrubbed",
+    "context_size": 1024,
+    "gpu_layers": "all",
+    "iterations": 3,
+    "llama_revision": "12127defda4f41b7679cb2477a4b0d65ee6a0c8f",
+    "max_new": 8,
+    "prompts": [
+      {
+        "ids": [
+          9419,
+          11,
+          1814
+        ],
+        "name": "hello_world",
+        "text": "Hello, world"
+      },
+      {
+        "ids": [
+          760,
+          6511,
+          314,
+          9338,
+          369
+        ],
+        "name": "paris",
+        "text": "The capital of France is"
+      },
+      {
+        "ids": [
+          17,
+          478,
+          220,
+          17,
+          283
+        ],
+        "name": "arithmetic",
+        "text": "2 + 2 ="
+      },
+      {
+        "ids": [
+          27336,
+          90162,
+          506
+        ],
+        "name": "freezing",
+        "text": "Water freezes at"
+      },
+      {
+        "ids": [
+          623,
+          12654,
+          11,
+          264,
+          1103,
+          59036
+        ],
+        "name": "python_comprehension",
+        "text": "In Python, a list comprehension"
+      },
+      {
+        "ids": [
+          161607,
+          110161,
+          14876
+        ],
+        "name": "japanese_capital",
+        "text": "\u65e5\u672c\u306e\u9996\u90fd\u306f"
+      },
+      {
+        "ids": [
+          760,
+          3841,
+          13477,
+          37550
+        ],
+        "name": "quick_fox",
+        "text": "The quick brown fox"
+      },
+      {
+        "ids": [
+          814,
+          20139,
+          22525,
+          303,
+          799,
+          11316,
+          25
+        ],
+        "name": "gravity",
+        "text": "Explain gravity in one sentence:"
+      },
+      {
+        "ids": [
+          49,
+          575,
+          14834,
+          27028
+        ],
+        "name": "rust_ownership",
+        "text": "Rust ownership prevents"
+      },
+      {
+        "ids": [
+          2592,
+          660,
+          18833,
+          513,
+          53702,
+          321,
+          48130,
+          369,
+          264,
+          7993,
+          11,
+          1179,
+          48130,
+          369
+        ],
+        "name": "logic_cat",
+        "text": "If all cats are mammals and Luna is a cat, then Luna is"
+      },
+      {
+        "ids": [
+          727,
+          73111,
+          1393,
+          1590
+        ],
+        "name": "fibonacci",
+        "text": "def fibonacci(n):"
+      },
+      {
+        "ids": [
+          26583,
+          1603,
+          6353,
+          310,
+          8323,
+          25
+        ],
+        "name": "french_translation",
+        "text": "Translate good morning to French:"
+      }
+    ],
+    "runner_owned_server": true,
+    "sampling": {
+      "cache_prompt": false,
+      "dry_multiplier": 0.0,
+      "frequency_penalty": 0.0,
+      "ignore_eos": true,
+      "min_p": 0.0,
+      "presence_penalty": 0.0,
+      "raw_token_input_output": true,
+      "repeat_penalty": 1.0,
+      "temperature": 0.0,
+      "top_k": 0,
+      "top_p": 1.0
+    },
+    "server_library_count": 13,
+    "server_library_directory": "proc-verified; path not stored",
+    "server_log_verbosity": "trace (raw log hashed, not stored)",
+    "server_origin": "http://127.0.0.1:47203",
+    "server_transport": "direct numeric-loopback HTTP; proxies and redirects disabled"
+  },
+  "failures": [],
+  "finished_at_utc": "2026-07-21T06:01:04.914411Z",
+  "fp_measurements": [
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 0,
+      "predicted_ms": 1082.62,
+      "predicted_per_second": 7.3894810736916,
+      "prompt": "hello_world",
+      "prompt_ms": 653.868,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 0,
+      "predicted_ms": 738.252,
+      "predicted_per_second": 10.836408164149912,
+      "prompt": "paris",
+      "prompt_ms": 946.161,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 0,
+      "predicted_ms": 718.429,
+      "predicted_per_second": 11.135407952629976,
+      "prompt": "arithmetic",
+      "prompt_ms": 693.798,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 0,
+      "predicted_ms": 728.506,
+      "predicted_per_second": 10.981378327700801,
+      "prompt": "freezing",
+      "prompt_ms": 341.705,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 0,
+      "predicted_ms": 732.376,
+      "predicted_per_second": 10.923350847105858,
+      "prompt": "python_comprehension",
+      "prompt_ms": 778.358,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 0,
+      "predicted_ms": 918.547,
+      "predicted_per_second": 8.7094073574896,
+      "prompt": "japanese_capital",
+      "prompt_ms": 437.907,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 0,
+      "predicted_ms": 721.807,
+      "predicted_per_second": 11.08329511905537,
+      "prompt": "quick_fox",
+      "prompt_ms": 218.716,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 0,
+      "predicted_ms": 869.591,
+      "predicted_per_second": 9.199727228087687,
+      "prompt": "gravity",
+      "prompt_ms": 828.626,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 0,
+      "predicted_ms": 723.562,
+      "predicted_per_second": 11.056412581091875,
+      "prompt": "rust_ownership",
+      "prompt_ms": 221.535,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 0,
+      "predicted_ms": 718.138,
+      "predicted_per_second": 11.139920182471892,
+      "prompt": "logic_cat",
+      "prompt_ms": 1093.64,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 0,
+      "predicted_ms": 730.162,
+      "predicted_per_second": 10.956472673187594,
+      "prompt": "fibonacci",
+      "prompt_ms": 224.781,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 0,
+      "predicted_ms": 710.613,
+      "predicted_per_second": 11.257885797192001,
+      "prompt": "french_translation",
+      "prompt_ms": 866.09,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 1,
+      "predicted_ms": 709.813,
+      "predicted_per_second": 11.270574080779022,
+      "prompt": "hello_world",
+      "prompt_ms": 372.217,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 1,
+      "predicted_ms": 712.815,
+      "predicted_per_second": 11.223108380154738,
+      "prompt": "paris",
+      "prompt_ms": 324.677,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 1,
+      "predicted_ms": 713.208,
+      "predicted_per_second": 11.21692409507465,
+      "prompt": "arithmetic",
+      "prompt_ms": 337.349,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 1,
+      "predicted_ms": 720.376,
+      "predicted_per_second": 11.105311670572036,
+      "prompt": "freezing",
+      "prompt_ms": 187.413,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 1,
+      "predicted_ms": 722.772,
+      "predicted_per_second": 11.068497396135987,
+      "prompt": "python_comprehension",
+      "prompt_ms": 371.388,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 1,
+      "predicted_ms": 707.655,
+      "predicted_per_second": 11.304943793232578,
+      "prompt": "japanese_capital",
+      "prompt_ms": 178.854,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 1,
+      "predicted_ms": 711.156,
+      "predicted_per_second": 11.249289888575785,
+      "prompt": "quick_fox",
+      "prompt_ms": 212.952,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 1,
+      "predicted_ms": 708.026,
+      "predicted_per_second": 11.29902009248248,
+      "prompt": "gravity",
+      "prompt_ms": 423.887,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 1,
+      "predicted_ms": 710.938,
+      "predicted_per_second": 11.252739338732773,
+      "prompt": "rust_ownership",
+      "prompt_ms": 231.229,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 1,
+      "predicted_ms": 728.763,
+      "predicted_per_second": 10.977505718594385,
+      "prompt": "logic_cat",
+      "prompt_ms": 541.674,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 1,
+      "predicted_ms": 721.807,
+      "predicted_per_second": 11.08329511905537,
+      "prompt": "fibonacci",
+      "prompt_ms": 214.87,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 1,
+      "predicted_ms": 734.181,
+      "predicted_per_second": 10.89649555082466,
+      "prompt": "french_translation",
+      "prompt_ms": 376.68,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "iteration": 2,
+      "predicted_ms": 721.0,
+      "predicted_per_second": 11.095700416088766,
+      "prompt": "hello_world",
+      "prompt_ms": 183.783,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        11751,
+        11,
+        264,
+        3177,
+        34756,
+        364,
+        1141,
+        25438
+      ],
+      "iteration": 2,
+      "predicted_ms": 719.404,
+      "predicted_per_second": 11.120316261794486,
+      "prompt": "paris",
+      "prompt_ms": 320.22,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        19,
+        13,
+        271,
+        2,
+        220,
+        16,
+        13
+      ],
+      "iteration": 2,
+      "predicted_ms": 715.695,
+      "predicted_per_second": 11.177945912714215,
+      "prompt": "arithmetic",
+      "prompt_ms": 323.291,
+      "stop_type": "limit",
+      "tokens_cached": 12
+    },
+    {
+      "generated": [
+        220,
+        15,
+        29922,
+        321,
+        85895,
+        506,
+        220,
+        16
+      ],
+      "iteration": 2,
+      "predicted_ms": 713.372,
+      "predicted_per_second": 11.214345390623686,
+      "prompt": "freezing",
+      "prompt_ms": 196.493,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        369,
+        264,
+        61446,
+        1560,
+        310,
+        1791,
+        11140,
+        3018
+      ],
+      "iteration": 2,
+      "predicted_ms": 710.884,
+      "predicted_per_second": 11.253594116620995,
+      "prompt": "python_comprehension",
+      "prompt_ms": 380.965,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    },
+    {
+      "generated": [
+        115197,
+        150553,
+        5205,
+        115197,
+        14876,
+        98823,
+        215293,
+        99605
+      ],
+      "iteration": 2,
+      "predicted_ms": 716.095,
+      "predicted_per_second": 11.171702078634818,
+      "prompt": "japanese_capital",
+      "prompt_ms": 176.717,
+      "stop_type": "limit",
+      "tokens_cached": 10
+    },
+    {
+      "generated": [
+        33075,
+        888,
+        279,
+        15217,
+        5388,
+        13,
+        198,
+        760
+      ],
+      "iteration": 2,
+      "predicted_ms": 717.309,
+      "predicted_per_second": 11.152794681232217,
+      "prompt": "quick_fox",
+      "prompt_ms": 220.073,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        90700,
+        8340,
+        25,
+        271,
+        16
+      ],
+      "iteration": 2,
+      "predicted_ms": 714.738,
+      "predicted_per_second": 11.192912647711468,
+      "prompt": "gravity",
+      "prompt_ms": 411.911,
+      "stop_type": "limit",
+      "tokens_cached": 14
+    },
+    {
+      "generated": [
+        795,
+        19963,
+        321,
+        4779,
+        35479,
+        539,
+        59724,
+        7077
+      ],
+      "iteration": 2,
+      "predicted_ms": 709.767,
+      "predicted_per_second": 11.271304526696788,
+      "prompt": "rust_ownership",
+      "prompt_ms": 216.054,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        264,
+        33784,
+        278,
+        13,
+        271,
+        1919,
+        369,
+        264
+      ],
+      "iteration": 2,
+      "predicted_ms": 707.988,
+      "predicted_per_second": 11.29962654734261,
+      "prompt": "logic_cat",
+      "prompt_ms": 536.024,
+      "stop_type": "limit",
+      "tokens_cached": 21
+    },
+    {
+      "generated": [
+        198,
+        262,
+        413,
+        307,
+        2564,
+        220,
+        15,
+        25
+      ],
+      "iteration": 2,
+      "predicted_ms": 715.542,
+      "predicted_per_second": 11.180336024999232,
+      "prompt": "fibonacci",
+      "prompt_ms": 232.483,
+      "stop_type": "limit",
+      "tokens_cached": 11
+    },
+    {
+      "generated": [
+        271,
+        248068,
+        198,
+        8160,
+        579,
+        264,
+        7047,
+        1817
+      ],
+      "iteration": 2,
+      "predicted_ms": 712.745,
+      "predicted_per_second": 11.224210622312327,
+      "prompt": "french_translation",
+      "prompt_ms": 362.176,
+      "stop_type": "limit",
+      "tokens_cached": 13
+    }
+  ],
+  "host": {
+    "machine": "x86_64",
+    "python": "3.12.3",
+    "release": "6.18.33.2-microsoft-standard-WSL2",
+    "system": "Linux"
+  },
+  "measurement_complete": true,
+  "quality": {
+    "compared_tokens": 96,
+    "exact_position_fraction": 1.0,
+    "exact_position_matches": 96,
+    "fully_identical_prompts": 12,
+    "interpretation": "Only tokens before the first divergence share an identical autoregressive context; later position matches are diagnostic, not an accuracy claim.",
+    "per_prompt": [
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "fully_identical": true,
+        "integer": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "hello_world"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "fully_identical": true,
+        "integer": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "paris"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          220,
+          19,
+          13,
+          271,
+          2,
+          220,
+          16,
+          13
+        ],
+        "fully_identical": true,
+        "integer": [
+          220,
+          19,
+          13,
+          271,
+          2,
+          220,
+          16,
+          13
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "arithmetic"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          220,
+          15,
+          29922,
+          321,
+          85895,
+          506,
+          220,
+          16
+        ],
+        "fully_identical": true,
+        "integer": [
+          220,
+          15,
+          29922,
+          321,
+          85895,
+          506,
+          220,
+          16
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "freezing"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          369,
+          264,
+          61446,
+          1560,
+          310,
+          1791,
+          11140,
+          3018
+        ],
+        "fully_identical": true,
+        "integer": [
+          369,
+          264,
+          61446,
+          1560,
+          310,
+          1791,
+          11140,
+          3018
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "python_comprehension"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          115197,
+          150553,
+          5205,
+          115197,
+          14876,
+          98823,
+          215293,
+          99605
+        ],
+        "fully_identical": true,
+        "integer": [
+          115197,
+          150553,
+          5205,
+          115197,
+          14876,
+          98823,
+          215293,
+          99605
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "japanese_capital"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          33075,
+          888,
+          279,
+          15217,
+          5388,
+          13,
+          198,
+          760
+        ],
+        "fully_identical": true,
+        "integer": [
+          33075,
+          888,
+          279,
+          15217,
+          5388,
+          13,
+          198,
+          760
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "quick_fox"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          271,
+          248068,
+          198,
+          90700,
+          8340,
+          25,
+          271,
+          16
+        ],
+        "fully_identical": true,
+        "integer": [
+          271,
+          248068,
+          198,
+          90700,
+          8340,
+          25,
+          271,
+          16
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "gravity"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          795,
+          19963,
+          321,
+          4779,
+          35479,
+          539,
+          59724,
+          7077
+        ],
+        "fully_identical": true,
+        "integer": [
+          795,
+          19963,
+          321,
+          4779,
+          35479,
+          539,
+          59724,
+          7077
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "rust_ownership"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          264,
+          33784,
+          278,
+          13,
+          271,
+          1919,
+          369,
+          264
+        ],
+        "fully_identical": true,
+        "integer": [
+          264,
+          33784,
+          278,
+          13,
+          271,
+          1919,
+          369,
+          264
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "logic_cat"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          198,
+          262,
+          413,
+          307,
+          2564,
+          220,
+          15,
+          25
+        ],
+        "fully_identical": true,
+        "integer": [
+          198,
+          262,
+          413,
+          307,
+          2564,
+          220,
+          15,
+          25
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "fibonacci"
+      },
+      {
+        "compared_tokens": 8,
+        "exact_position_matches": 8,
+        "first_divergence_index": null,
+        "fp": [
+          271,
+          248068,
+          198,
+          8160,
+          579,
+          264,
+          7047,
+          1817
+        ],
+        "fully_identical": true,
+        "integer": [
+          271,
+          248068,
+          198,
+          8160,
+          579,
+          264,
+          7047,
+          1817
+        ],
+        "prefix_match_tokens": 8,
+        "prompt": "french_translation"
+      }
+    ],
+    "prefix_match_fraction": 1.0,
+    "prefix_match_tokens": 96,
+    "prompt_count": 12
+  },
+  "reference": {
+    "artifacts": {
+      "corpus": {
+        "basename": "qi35-calibration-prompts-v1.json",
+        "bytes": 1726,
+        "sha256": "7e05acc22fa58445b92ff8e9edf2466ea9eb107e76f43ae087449d7976b513bd"
+      },
+      "engine": {
+        "basename": "qi35_model",
+        "bytes": 818504,
+        "sha256": "48885e73492216cb7b1d5065d74e333099eaef065a92c0ff6602226eb2ff3abf"
+      },
+      "engine_libraries": [
+        {
+          "basename": "libqi35metal.dylib",
+          "bytes": 172976,
+          "sha256": "7ac3a1230840d0cbb29407a256e6c8e3fe6f8c2b0240e0a92dd705fa46e41f75"
+        }
+      ],
+      "engine_source": {
+        "basename": "qi35_model.rs",
+        "bytes": 100161,
+        "sha256": "098385055c5e1bc6a9cd6229a06a14be53e8403ea89d4f3ba9b53457c210eecd"
+      },
+      "llama_libraries": [
+        {
+          "basename": "libllama-server-impl.dylib",
+          "bytes": 3518936,
+          "sha256": "50270f32da282e10744ca576070111baf84a9b40fd6804c66533647344331f6f"
+        },
+        {
+          "basename": "libllama-common.0.0.10015.dylib",
+          "bytes": 4969832,
+          "sha256": "82f3f6f2f76d023d92849f9b21869130ed8c6618822dbdf2aa3067cdf9057bc4"
+        },
+        {
+          "basename": "libmtmd.0.0.10015.dylib",
+          "bytes": 1029920,
+          "sha256": "d7fa3d3459d9767fcd1007cdf9a981ea34347048659c802f252c26260c6bb4c8"
+        },
+        {
+          "basename": "libllama.0.0.10015.dylib",
+          "bytes": 2663088,
+          "sha256": "47a22694597b7b2e6004aafeb7eb364294b147713bc3ef6f8fc51208013f794b"
+        },
+        {
+          "basename": "libggml.0.16.0.dylib",
+          "bytes": 59808,
+          "sha256": "dbfdb8f69df9e05d54531d41fed4b950a41f67ad4cd0365b899776f3a824e4e1"
+        },
+        {
+          "basename": "libggml-base.0.16.0.dylib",
+          "bytes": 711208,
+          "sha256": "812c578136444f135b8a6b5f113ab012b8b48c27690e09058c326f7ff9b8be73"
+        },
+        {
+          "basename": "libggml-cpu.0.16.0.dylib",
+          "bytes": 934320,
+          "sha256": "172f0c200769b4373be3a8daed008e67cc6b974f3f73e4a5c1a9be31bba45c29"
+        },
+        {
+          "basename": "libggml-blas.0.16.0.dylib",
+          "bytes": 58776,
+          "sha256": "37fc972ce379db614b35f2f115f40358fb7934cc66b981444043087f371d34e2"
+        },
+        {
+          "basename": "libggml-metal.0.16.0.dylib",
+          "bytes": 849400,
+          "sha256": "7821024d78bc4152b6bcd871eeb6bc63207107709fe0c6afd3b6cf6e21677bf0"
+        }
+      ],
+      "llama_patch": {
+        "basename": "llama.cpp-palw-full.patch",
+        "bytes": 305392,
+        "sha256": "25f7062c3a930daf108a146f178c714c8978d92c83fa6d30af1f951705a8f62b"
+      },
+      "llama_server": {
+        "basename": "llama-server",
+        "bytes": 33472,
+        "sha256": "ad2946371ae4abe62115dc514dee11f4655ed117d718b714b338b00d82e039e0"
+      },
+      "model": {
+        "basename": "Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+        "bytes": 23938321728,
+        "sha256": "1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b"
+      },
+      "runner": {
+        "basename": "qi35_calibrate.py",
+        "bytes": 20692,
+        "sha256": "8ee83b038e58c3ebd943bf41a85caed6fa7015d2b73d36de33f3ac654871e252"
+      },
+      "soak_library": {
+        "basename": "qi35_soak.py",
+        "bytes": 38620,
+        "sha256": "977e8e39830d975c005864a5a2a5ebc2dc1c7300f8c829c21d5905c7a0e5fa7d"
+      },
+      "tables": {
+        "basename": "qi35_tables.bin",
+        "bytes": 4849688,
+        "sha256": "feb22fd1864a1396b9c2bc20937f3acad79bffefdefc71c50b3747da47b64c6e"
+      },
+      "tokenizer": {
+        "basename": "tokenizer.json",
+        "bytes": 19989343,
+        "sha256": "87a7830d63fcf43bf241c3c5242e96e62dd3fdc29224ca26fed8ea333db72de4"
+      }
+    },
+    "host": {
+      "hw.memsize": "34359738368",
+      "hw.model": "Mac13,1",
+      "machdep.cpu.brand_string": "Apple M1 Max",
+      "machine": "arm64",
+      "python": "3.14.4",
+      "release": "25.5.0",
+      "system": "Darwin"
+    }
+  },
+  "schema": "misaka.qi35.fp-cross-host-probe.v2",
+  "scope": "Cross-host floating-point CUDA calibration only; this does not claim a canonical-integer CUDA backend.",
+  "server_attestation": {
+    "cuda": {
+      "accelerator_inventory_count": 1,
+      "build_revision": "12127def",
+      "cuda_device_count": 1,
+      "full_gpu_layer_offload": true,
+      "gpu_layers_requested": "all",
+      "offloaded_layers": 41,
+      "total_offloadable_layers": 41
+    },
+    "process": {
+      "executable": {
+        "basename": "llama-server",
+        "bytes": 17920,
+        "sha256": "96e0a5024a36b0e1be07a89c93687e01222db76c62005b4c8b893b50677c6523"
+      },
+      "loader_environment_match": true,
+      "loader_path_stored": false,
+      "proc_cmdline_match": true,
+      "proc_exe_match": true,
+      "proc_model_mapping_match": true,
+      "proc_numeric_loopback_listener_match": true
+    },
+    "runner_owned_process": true,
+    "runtime_libraries": {
+      "all_declared_loaded": true,
+      "all_runtime_relevant_mappings_declared": true,
+      "bindings": [
+        {
+          "declared": {
+            "basename": "libllama-server-impl.so",
+            "bytes": 7042320,
+            "sha256": "7343188e7ee905280d0cdf1e5174854dea9d8b03fb181e0c714e232541aa792f"
+          },
+          "mapped_basename": "libllama-server-impl.so",
+          "mapped_bytes": 7042320,
+          "mapped_sha256": "7343188e7ee905280d0cdf1e5174854dea9d8b03fb181e0c714e232541aa792f",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libllama-common.so.0.0.10015",
+            "bytes": 5957384,
+            "sha256": "e3f8449d15d053d0f3d60216e79b15d0e1161e57f282e32f04082bd28d801332"
+          },
+          "mapped_basename": "libllama-common.so.0.0.10015",
+          "mapped_bytes": 5957384,
+          "mapped_sha256": "e3f8449d15d053d0f3d60216e79b15d0e1161e57f282e32f04082bd28d801332",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libmtmd.so.0.0.10015",
+            "bytes": 1432176,
+            "sha256": "6140a8bd358f1d5292e491b057c290e86691b9fd2eb6f1a81a8c0f659b8a6988"
+          },
+          "mapped_basename": "libmtmd.so.0.0.10015",
+          "mapped_bytes": 1432176,
+          "mapped_sha256": "6140a8bd358f1d5292e491b057c290e86691b9fd2eb6f1a81a8c0f659b8a6988",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libllama.so.0.0.10015",
+            "bytes": 4121720,
+            "sha256": "71993fce88235ef4a7ab95b7d6d824fff24997312cae9cca636d82debf1ac200"
+          },
+          "mapped_basename": "libllama.so.0.0.10015",
+          "mapped_bytes": 4121720,
+          "mapped_sha256": "71993fce88235ef4a7ab95b7d6d824fff24997312cae9cca636d82debf1ac200",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libggml.so.0.16.0",
+            "bytes": 56016,
+            "sha256": "e7fec42f7a61faa5a070c94777edbf3a096b679cf4390e1dea7676f2f9024d89"
+          },
+          "mapped_basename": "libggml.so.0.16.0",
+          "mapped_bytes": 56016,
+          "mapped_sha256": "e7fec42f7a61faa5a070c94777edbf3a096b679cf4390e1dea7676f2f9024d89",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libggml-base.so.0.16.0",
+            "bytes": 913832,
+            "sha256": "8fe45b635da3d69dff4980ea6bb558fecfac8c495f6208ab328d7aee7be8ae26"
+          },
+          "mapped_basename": "libggml-base.so.0.16.0",
+          "mapped_bytes": 913832,
+          "mapped_sha256": "8fe45b635da3d69dff4980ea6bb558fecfac8c495f6208ab328d7aee7be8ae26",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libggml-cpu.so.0.16.0",
+            "bytes": 1135432,
+            "sha256": "7ff647de57ee0d67e3a76c8aedfe74595fe73ffef2c306dd1d37f3b6240a336b"
+          },
+          "mapped_basename": "libggml-cpu.so.0.16.0",
+          "mapped_bytes": 1135432,
+          "mapped_sha256": "7ff647de57ee0d67e3a76c8aedfe74595fe73ffef2c306dd1d37f3b6240a336b",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libggml-cuda.so.0.16.0",
+            "bytes": 63387424,
+            "sha256": "52eefb8d73bbdac9126c9285112d3ba2568353565fdd0cae726a4f4781c7e262"
+          },
+          "mapped_basename": "libggml-cuda.so.0.16.0",
+          "mapped_bytes": 63387424,
+          "mapped_sha256": "52eefb8d73bbdac9126c9285112d3ba2568353565fdd0cae726a4f4781c7e262",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libcudart.so.13.3.29",
+            "bytes": 782080,
+            "sha256": "9f92e4c3f7e14d0fed69ef876a45d4255a2dc88cb552a673a90ce881c26282fe"
+          },
+          "mapped_basename": "libcudart.so.13.3.29",
+          "mapped_bytes": 782080,
+          "mapped_sha256": "9f92e4c3f7e14d0fed69ef876a45d4255a2dc88cb552a673a90ce881c26282fe",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libcublas.so.13.6.0.2",
+            "bytes": 55354008,
+            "sha256": "01dd70979e68625846e9a5edcba531d3798498b866aa1c925cc25d60f63fe680"
+          },
+          "mapped_basename": "libcublas.so.13.6.0.2",
+          "mapped_bytes": 55354008,
+          "mapped_sha256": "01dd70979e68625846e9a5edcba531d3798498b866aa1c925cc25d60f63fe680",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libcublasLt.so.13.6.0.2",
+            "bytes": 516598272,
+            "sha256": "93c275af70b6d39fbd9b78cbc925ad9a9a0a81189aaec1521a951119ebe72da3"
+          },
+          "mapped_basename": "libcublasLt.so.13.6.0.2",
+          "mapped_bytes": 516598272,
+          "mapped_sha256": "93c275af70b6d39fbd9b78cbc925ad9a9a0a81189aaec1521a951119ebe72da3",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libcuda.so.1.1",
+            "bytes": 187984,
+            "sha256": "158e0c4e9427a5fbc34ebe07000505744adf115f3baf857dae87dcf1f0674732"
+          },
+          "mapped_basename": "libcuda.so.1",
+          "mapped_bytes": 187984,
+          "mapped_sha256": "158e0c4e9427a5fbc34ebe07000505744adf115f3baf857dae87dcf1f0674732",
+          "runtime_relevant": true
+        },
+        {
+          "declared": {
+            "basename": "libcuda.so.1.1",
+            "bytes": 27803920,
+            "sha256": "97ba7b6097a38febf9e40ac0c27da10bdc717efdad498a4870aa783b058d7ace"
+          },
+          "mapped_basename": "libcuda.so.1.1",
+          "mapped_bytes": 27803920,
+          "mapped_sha256": "97ba7b6097a38febf9e40ac0c27da10bdc717efdad498a4870aa783b058d7ace",
+          "runtime_relevant": true
+        }
+      ],
+      "declared_count": 13,
+      "libggml_cuda": {
+        "basename": "libggml-cuda.so.0.16.0",
+        "bytes": 63387424,
+        "sha256": "52eefb8d73bbdac9126c9285112d3ba2568353565fdd0cae726a4f4781c7e262"
+      },
+      "loaded_binding_count": 13,
+      "runtime_relevant_mapping_count": 13
+    },
+    "schema": "misaka.qi35.runner-owned-cuda-server-attestation.v1",
+    "startup_log": {
+      "line_count": 246,
+      "sha256": "67918187609745ef2d967e99eb2bb790a0f17eddbaa0799c366efa63488103de",
+      "stored_verbatim": false
+    },
+    "transport": {
+      "http_proxy": "disabled",
+      "http_redirects": "disabled",
+      "numeric_loopback": "127.0.0.1"
+    }
+  },
+  "started_at_utc": "2026-07-21T05:53:47.327491Z"
+}
diff --git a/docs/evidence/reports/qi35-soak-mac-20260721-v1.json b/docs/evidence/reports/qi35-soak-mac-20260721-v1.json
new file mode 100644
index 0000000000000000000000000000000000000000..995a03aacba8e0779e70d3b8b29d648a61fac3f9
--- /dev/null
+++ b/docs/evidence/reports/qi35-soak-mac-20260721-v1.json
@@ -0,0 +1,1443 @@
+{
+  "artifacts": {
+    "engine": {
+      "basename": "qi35_model-portable-mac",
+      "bytes": 818520,
+      "sha256": "242a3614eea9e129e0ef9a48c5f8ca320c3b6eb4c616e82c50fdc4f6de631660"
+    },
+    "model": {
+      "basename": "Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+      "bytes": 23938321728,
+      "sha256": "1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b"
+    },
+    "source": {
+      "basename": "qi35_model.rs",
+      "bytes": 100161,
+      "sha256": "098385055c5e1bc6a9cd6229a06a14be53e8403ea89d4f3ba9b53457c210eecd"
+    },
+    "tables": {
+      "basename": "qi35_tables.bin",
+      "bytes": 4849688,
+      "sha256": "feb22fd1864a1396b9c2bc20937f3acad79bffefdefc71c50b3747da47b64c6e"
+    }
+  },
+  "backends": [
+    {
+      "executable_sha256": "242a3614eea9e129e0ef9a48c5f8ca320c3b6eb4c616e82c50fdc4f6de631660",
+      "explicit_environment": {
+        "DYLD_LIBRARY_PATH": "<configured-loader-path>"
+      },
+      "flags": [],
+      "latency_seconds": {
+        "max": 7.42,
+        "median": 6.365,
+        "min": 5.68,
+        "p95": 6.94
+      },
+      "measurements": 40,
+      "name": "cpu",
+      "seconds": 251.88,
+      "stderr_tail": [
+        "SERVE_READY backend=rust-cpu-aarch64 receipts=false"
+      ],
+      "tokens": 320,
+      "tokens_per_second": 1.270446
+    },
+    {
+      "executable_sha256": "242a3614eea9e129e0ef9a48c5f8ca320c3b6eb4c616e82c50fdc4f6de631660",
+      "explicit_environment": {
+        "DYLD_LIBRARY_PATH": "<configured-loader-path>"
+      },
+      "flags": [
+        "--metal-v3"
+      ],
+      "latency_seconds": {
+        "max": 6.11,
+        "median": 4.48,
+        "min": 3.79,
+        "p95": 5.39
+      },
+      "measurements": 40,
+      "name": "metal-v3",
+      "seconds": 176.03,
+      "stderr_tail": [
+        "qi35metal: maxBufferLength=20100448256",
+        "metal offload: ON",
+        "metal v3 (moe+deltanet+attention on-device): ON (kv bind0 1024 rows/layer)",
+        "SERVE_READY backend=rust-cpu-aarch64 receipts=false"
+      ],
+      "tokens": 320,
+      "tokens_per_second": 1.817872
+    }
+  ],
+  "configuration": {
+    "inherited_qi35_environment": "scrubbed",
+    "iterations": 20,
+    "max_new": 8,
+    "prompts": [
+      {
+        "ids": [
+          9419,
+          11,
+          1814
+        ],
+        "name": "hello"
+      },
+      {
+        "ids": [
+          760,
+          6511,
+          314,
+          9338,
+          369
+        ],
+        "name": "paris"
+      }
+    ],
+    "threads": 8,
+    "warmup": 2
+  },
+  "criteria": {
+    "cross_backend_execution_roots": "generated ids, FNV64, route root, KV root, and state root are identical",
+    "cross_backend_tokens": "every scheduled generated token sequence is identical",
+    "independent_host_reference": false,
+    "local_backend_count": 2,
+    "minimum_local_backends_without_reference": 2,
+    "reset_determinism": "every prompt output is invariant across iterations"
+  },
+  "finished_at_utc": "2026-07-21T02:50:20.498074Z",
+  "host": {
+    "hw.memsize": "34359738368",
+    "hw.model": "Mac13,1",
+    "machdep.cpu.brand_string": "Apple M1 Max",
+    "machine": "arm64",
+    "python": "3.14.4",
+    "release": "25.5.0",
+    "system": "Darwin"
+  },
+  "measurements": {
+    "cpu": [
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 0,
+        "prompt": "hello",
+        "seconds": 5.89,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 0,
+        "prompt": "paris",
+        "seconds": 6.72,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 1,
+        "prompt": "hello",
+        "seconds": 5.71,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 1,
+        "prompt": "paris",
+        "seconds": 6.58,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 2,
+        "prompt": "hello",
+        "seconds": 5.79,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 2,
+        "prompt": "paris",
+        "seconds": 6.69,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 3,
+        "prompt": "hello",
+        "seconds": 5.94,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 3,
+        "prompt": "paris",
+        "seconds": 6.73,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 4,
+        "prompt": "hello",
+        "seconds": 5.82,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 4,
+        "prompt": "paris",
+        "seconds": 6.62,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 5,
+        "prompt": "hello",
+        "seconds": 5.68,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 5,
+        "prompt": "paris",
+        "seconds": 6.82,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 6,
+        "prompt": "hello",
+        "seconds": 5.74,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 6,
+        "prompt": "paris",
+        "seconds": 6.77,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 7,
+        "prompt": "hello",
+        "seconds": 5.85,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 7,
+        "prompt": "paris",
+        "seconds": 6.78,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 8,
+        "prompt": "hello",
+        "seconds": 5.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 8,
+        "prompt": "paris",
+        "seconds": 6.65,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 9,
+        "prompt": "hello",
+        "seconds": 5.8,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 9,
+        "prompt": "paris",
+        "seconds": 6.7,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 10,
+        "prompt": "hello",
+        "seconds": 5.76,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 10,
+        "prompt": "paris",
+        "seconds": 6.65,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 11,
+        "prompt": "hello",
+        "seconds": 5.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 11,
+        "prompt": "paris",
+        "seconds": 6.83,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 12,
+        "prompt": "hello",
+        "seconds": 5.79,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 12,
+        "prompt": "paris",
+        "seconds": 7.42,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 13,
+        "prompt": "hello",
+        "seconds": 5.88,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 13,
+        "prompt": "paris",
+        "seconds": 6.66,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 14,
+        "prompt": "hello",
+        "seconds": 5.77,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 14,
+        "prompt": "paris",
+        "seconds": 6.64,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 15,
+        "prompt": "hello",
+        "seconds": 5.72,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 15,
+        "prompt": "paris",
+        "seconds": 6.66,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 16,
+        "prompt": "hello",
+        "seconds": 5.82,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 16,
+        "prompt": "paris",
+        "seconds": 6.77,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 17,
+        "prompt": "hello",
+        "seconds": 5.87,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 17,
+        "prompt": "paris",
+        "seconds": 6.94,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 18,
+        "prompt": "hello",
+        "seconds": 6.15,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 18,
+        "prompt": "paris",
+        "seconds": 6.78,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 19,
+        "prompt": "hello",
+        "seconds": 5.78,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 19,
+        "prompt": "paris",
+        "seconds": 7.03,
+        "tokens": 8
+      }
+    ],
+    "metal-v3": [
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 0,
+        "prompt": "hello",
+        "seconds": 3.81,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 0,
+        "prompt": "paris",
+        "seconds": 4.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 1,
+        "prompt": "hello",
+        "seconds": 4.12,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 1,
+        "prompt": "paris",
+        "seconds": 4.45,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 2,
+        "prompt": "hello",
+        "seconds": 3.8,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 2,
+        "prompt": "paris",
+        "seconds": 4.49,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 3,
+        "prompt": "hello",
+        "seconds": 3.81,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 3,
+        "prompt": "paris",
+        "seconds": 4.48,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 4,
+        "prompt": "hello",
+        "seconds": 3.9,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 4,
+        "prompt": "paris",
+        "seconds": 4.59,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 5,
+        "prompt": "hello",
+        "seconds": 4.5,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 5,
+        "prompt": "paris",
+        "seconds": 4.94,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 6,
+        "prompt": "hello",
+        "seconds": 3.79,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 6,
+        "prompt": "paris",
+        "seconds": 4.48,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 7,
+        "prompt": "hello",
+        "seconds": 3.82,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 7,
+        "prompt": "paris",
+        "seconds": 4.45,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 8,
+        "prompt": "hello",
+        "seconds": 4.58,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 8,
+        "prompt": "paris",
+        "seconds": 4.49,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 9,
+        "prompt": "hello",
+        "seconds": 4.24,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 9,
+        "prompt": "paris",
+        "seconds": 5.11,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 10,
+        "prompt": "hello",
+        "seconds": 5.39,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 10,
+        "prompt": "paris",
+        "seconds": 5.41,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 11,
+        "prompt": "hello",
+        "seconds": 4.23,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 11,
+        "prompt": "paris",
+        "seconds": 6.11,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 12,
+        "prompt": "hello",
+        "seconds": 4.53,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 12,
+        "prompt": "paris",
+        "seconds": 4.88,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 13,
+        "prompt": "hello",
+        "seconds": 3.81,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 13,
+        "prompt": "paris",
+        "seconds": 4.51,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 14,
+        "prompt": "hello",
+        "seconds": 3.81,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 14,
+        "prompt": "paris",
+        "seconds": 4.49,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 15,
+        "prompt": "hello",
+        "seconds": 3.8,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 15,
+        "prompt": "paris",
+        "seconds": 4.48,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 16,
+        "prompt": "hello",
+        "seconds": 3.8,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 16,
+        "prompt": "paris",
+        "seconds": 4.48,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 17,
+        "prompt": "hello",
+        "seconds": 3.8,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 17,
+        "prompt": "paris",
+        "seconds": 5.21,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 18,
+        "prompt": "hello",
+        "seconds": 3.83,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 18,
+        "prompt": "paris",
+        "seconds": 4.47,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 19,
+        "prompt": "hello",
+        "seconds": 3.82,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 19,
+        "prompt": "paris",
+        "seconds": 4.48,
+        "tokens": 8
+      }
+    ]
+  },
+  "mismatches": [],
+  "passed": true,
+  "root_check_prompt": "hello",
+  "root_checks": {
+    "cpu": {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "ids_fnv64": "ff03bf7c9a5d7593",
+      "kv_root": "b1e7b7e926aebca7cea2551b9c2945618b60ea600b1d52c2e8a843d477680254",
+      "route_root": "4ce2ca21a5ba24e388471e856cc159f5f127d2e911f4b37bafaf31e13e00cb6a",
+      "state_root": "3ae83ec82a0f7f833388137a6eea0186339f6d1e5efcd87076264816a8109386"
+    },
+    "metal-v3": {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "ids_fnv64": "ff03bf7c9a5d7593",
+      "kv_root": "b1e7b7e926aebca7cea2551b9c2945618b60ea600b1d52c2e8a843d477680254",
+      "route_root": "4ce2ca21a5ba24e388471e856cc159f5f127d2e911f4b37bafaf31e13e00cb6a",
+      "state_root": "3ae83ec82a0f7f833388137a6eea0186339f6d1e5efcd87076264816a8109386"
+    }
+  },
+  "schema": "misaka.qi35.hardware-soak.v1",
+  "started_at_utc": "2026-07-21T02:41:41.128004Z"
+}
diff --git a/docs/evidence/reports/qi35-soak-mac-20260721-v2.json b/docs/evidence/reports/qi35-soak-mac-20260721-v2.json
new file mode 100644
index 0000000000000000000000000000000000000000..426c05914eff59898bff0e20ed9de99b8525adf9
--- /dev/null
+++ b/docs/evidence/reports/qi35-soak-mac-20260721-v2.json
@@ -0,0 +1,1512 @@
+{
+  "artifacts": {
+    "engine": {
+      "basename": "qi35_model",
+      "bytes": 818504,
+      "sha256": "48885e73492216cb7b1d5065d74e333099eaef065a92c0ff6602226eb2ff3abf"
+    },
+    "model": {
+      "basename": "Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+      "bytes": 23938321728,
+      "sha256": "1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b"
+    },
+    "runner": {
+      "basename": "qi35_soak.py",
+      "bytes": 38620,
+      "sha256": "977e8e39830d975c005864a5a2a5ebc2dc1c7300f8c829c21d5905c7a0e5fa7d"
+    },
+    "runtime_libraries": [
+      {
+        "basename": "libqi35metal.dylib",
+        "bytes": 172976,
+        "sha256": "7ac3a1230840d0cbb29407a256e6c8e3fe6f8c2b0240e0a92dd705fa46e41f75"
+      }
+    ],
+    "source": {
+      "basename": "qi35_model.rs",
+      "bytes": 100161,
+      "sha256": "098385055c5e1bc6a9cd6229a06a14be53e8403ea89d4f3ba9b53457c210eecd"
+    },
+    "tables": {
+      "basename": "qi35_tables.bin",
+      "bytes": 4849688,
+      "sha256": "feb22fd1864a1396b9c2bc20937f3acad79bffefdefc71c50b3747da47b64c6e"
+    }
+  },
+  "backends": [
+    {
+      "executable_sha256": "48885e73492216cb7b1d5065d74e333099eaef065a92c0ff6602226eb2ff3abf",
+      "explicit_environment": {
+        "DYLD_LIBRARY_PATH": "<configured-loader-path>"
+      },
+      "flags": [],
+      "latency_seconds": {
+        "max": 27.93,
+        "median": 5.655,
+        "min": 4.77,
+        "p95": 9.05
+      },
+      "measurements": 40,
+      "name": "cpu",
+      "seconds": 254.43,
+      "stderr_tail": [
+        "SERVE_READY backend=rust-cpu-aarch64 receipts=false"
+      ],
+      "tokens": 320,
+      "tokens_per_second": 1.257713
+    },
+    {
+      "executable_sha256": "48885e73492216cb7b1d5065d74e333099eaef065a92c0ff6602226eb2ff3abf",
+      "explicit_environment": {
+        "DYLD_LIBRARY_PATH": "<configured-loader-path>"
+      },
+      "flags": [
+        "--metal-v3"
+      ],
+      "latency_seconds": {
+        "max": 3.35,
+        "median": 3.085,
+        "min": 2.83,
+        "p95": 3.34
+      },
+      "measurements": 40,
+      "name": "metal-v3",
+      "seconds": 123.57,
+      "stderr_tail": [
+        "qi35metal: maxBufferLength=20100448256",
+        "metal offload: ON",
+        "metal v3 (moe+deltanet+attention on-device): ON (kv bind0 1024 rows/layer)",
+        "SERVE_READY backend=rust-cpu-aarch64 receipts=false"
+      ],
+      "tokens": 320,
+      "tokens_per_second": 2.589625
+    }
+  ],
+  "configuration": {
+    "inherited_qi35_environment": "scrubbed",
+    "iterations": 20,
+    "max_new": 8,
+    "non_system_runtime_library_count": 1,
+    "prompts": [
+      {
+        "ids": [
+          9419,
+          11,
+          1814
+        ],
+        "name": "hello"
+      },
+      {
+        "ids": [
+          760,
+          6511,
+          314,
+          9338,
+          369
+        ],
+        "name": "paris"
+      }
+    ],
+    "threads": 8,
+    "warmup": 2
+  },
+  "criteria": {
+    "artifact_provenance": "runner, backend plan, and every declared non-system runtime library are content-addressed",
+    "cross_backend_execution_roots": "generated ids, FNV64, route root, KV root, and state root are identical",
+    "cross_backend_tokens": "every scheduled generated token sequence is identical",
+    "independent_host_reference": false,
+    "local_backend_count": 2,
+    "minimum_local_backends_without_reference": 2,
+    "reset_determinism": "every prompt output is invariant across iterations"
+  },
+  "finished_at_utc": "2026-07-21T05:07:02.205428Z",
+  "host": {
+    "hw.memsize": "34359738368",
+    "hw.model": "Mac13,1",
+    "machdep.cpu.brand_string": "Apple M1 Max",
+    "machine": "arm64",
+    "python": "3.14.4",
+    "release": "25.5.0",
+    "system": "Darwin"
+  },
+  "measurements": {
+    "cpu": [
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 0,
+        "prompt": "hello",
+        "seconds": 4.81,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 0,
+        "prompt": "paris",
+        "seconds": 5.72,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 1,
+        "prompt": "hello",
+        "seconds": 4.92,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 1,
+        "prompt": "paris",
+        "seconds": 5.7,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 2,
+        "prompt": "hello",
+        "seconds": 4.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 2,
+        "prompt": "paris",
+        "seconds": 5.69,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 3,
+        "prompt": "hello",
+        "seconds": 4.83,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 3,
+        "prompt": "paris",
+        "seconds": 5.72,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 4,
+        "prompt": "hello",
+        "seconds": 5.32,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 4,
+        "prompt": "paris",
+        "seconds": 7.24,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 5,
+        "prompt": "hello",
+        "seconds": 4.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 5,
+        "prompt": "paris",
+        "seconds": 5.98,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 6,
+        "prompt": "hello",
+        "seconds": 4.88,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 6,
+        "prompt": "paris",
+        "seconds": 5.74,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 7,
+        "prompt": "hello",
+        "seconds": 5.04,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 7,
+        "prompt": "paris",
+        "seconds": 5.65,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 8,
+        "prompt": "hello",
+        "seconds": 5.02,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 8,
+        "prompt": "paris",
+        "seconds": 5.62,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 9,
+        "prompt": "hello",
+        "seconds": 4.92,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 9,
+        "prompt": "paris",
+        "seconds": 5.8,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 10,
+        "prompt": "hello",
+        "seconds": 4.9,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 10,
+        "prompt": "paris",
+        "seconds": 8.85,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 11,
+        "prompt": "hello",
+        "seconds": 7.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 11,
+        "prompt": "paris",
+        "seconds": 27.93,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 12,
+        "prompt": "hello",
+        "seconds": 6.02,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 12,
+        "prompt": "paris",
+        "seconds": 10.05,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 13,
+        "prompt": "hello",
+        "seconds": 5.3,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 13,
+        "prompt": "paris",
+        "seconds": 5.57,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 14,
+        "prompt": "hello",
+        "seconds": 4.77,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 14,
+        "prompt": "paris",
+        "seconds": 5.75,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 15,
+        "prompt": "hello",
+        "seconds": 4.93,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 15,
+        "prompt": "paris",
+        "seconds": 5.66,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 16,
+        "prompt": "hello",
+        "seconds": 4.99,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 16,
+        "prompt": "paris",
+        "seconds": 5.74,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 17,
+        "prompt": "hello",
+        "seconds": 4.96,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 17,
+        "prompt": "paris",
+        "seconds": 5.8,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 18,
+        "prompt": "hello",
+        "seconds": 7.58,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 18,
+        "prompt": "paris",
+        "seconds": 9.05,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 19,
+        "prompt": "hello",
+        "seconds": 4.81,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 19,
+        "prompt": "paris",
+        "seconds": 6.15,
+        "tokens": 8
+      }
+    ],
+    "metal-v3": [
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 0,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 0,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 1,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 1,
+        "prompt": "paris",
+        "seconds": 3.33,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 2,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 2,
+        "prompt": "paris",
+        "seconds": 3.35,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 3,
+        "prompt": "hello",
+        "seconds": 2.83,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 3,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 4,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 4,
+        "prompt": "paris",
+        "seconds": 3.33,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 5,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 5,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 6,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 6,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 7,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 7,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 8,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 8,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 9,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 9,
+        "prompt": "paris",
+        "seconds": 3.33,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 10,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 10,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 11,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 11,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 12,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 12,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 13,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 13,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 14,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 14,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 15,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 15,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 16,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 16,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 17,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 17,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 18,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 18,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 19,
+        "prompt": "hello",
+        "seconds": 2.84,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 19,
+        "prompt": "paris",
+        "seconds": 3.34,
+        "tokens": 8
+      }
+    ]
+  },
+  "mismatches": [],
+  "passed": true,
+  "reproducibility": {
+    "backend_plan": {
+      "canonical_sha256": "493b001d2267beeb01c5ea551c804dff20c817d17ccdc19244ea3f821b85b658",
+      "kind": "built-in",
+      "normalized_backends": [
+        {
+          "environment": {
+            "DYLD_LIBRARY_PATH": "<configured-loader-path>"
+          },
+          "executable": {
+            "basename": "qi35_model",
+            "bytes": 818504,
+            "sha256": "48885e73492216cb7b1d5065d74e333099eaef065a92c0ff6602226eb2ff3abf"
+          },
+          "flags": [],
+          "name": "cpu"
+        },
+        {
+          "environment": {
+            "DYLD_LIBRARY_PATH": "<configured-loader-path>"
+          },
+          "executable": {
+            "basename": "qi35_model",
+            "bytes": 818504,
+            "sha256": "48885e73492216cb7b1d5065d74e333099eaef065a92c0ff6602226eb2ff3abf"
+          },
+          "flags": [
+            "--metal-v3"
+          ],
+          "name": "metal-v3"
+        }
+      ],
+      "selected_backends": [
+        "cpu",
+        "metal-v3"
+      ]
+    },
+    "non_system_runtime_libraries": {
+      "artifacts": [
+        {
+          "basename": "libqi35metal.dylib",
+          "bytes": 172976,
+          "sha256": "7ac3a1230840d0cbb29407a256e6c8e3fe6f8c2b0240e0a92dd705fa46e41f75"
+        }
+      ],
+      "count": 1,
+      "declaration": "explicit-files"
+    },
+    "runner": {
+      "basename": "qi35_soak.py",
+      "bytes": 38620,
+      "sha256": "977e8e39830d975c005864a5a2a5ebc2dc1c7300f8c829c21d5905c7a0e5fa7d"
+    },
+    "schema": "misaka.qi35.soak-reproducibility.v1"
+  },
+  "root_check_prompt": "hello",
+  "root_checks": {
+    "cpu": {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "ids_fnv64": "ff03bf7c9a5d7593",
+      "kv_root": "b1e7b7e926aebca7cea2551b9c2945618b60ea600b1d52c2e8a843d477680254",
+      "route_root": "4ce2ca21a5ba24e388471e856cc159f5f127d2e911f4b37bafaf31e13e00cb6a",
+      "state_root": "3ae83ec82a0f7f833388137a6eea0186339f6d1e5efcd87076264816a8109386"
+    },
+    "metal-v3": {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "ids_fnv64": "ff03bf7c9a5d7593",
+      "kv_root": "b1e7b7e926aebca7cea2551b9c2945618b60ea600b1d52c2e8a843d477680254",
+      "route_root": "4ce2ca21a5ba24e388471e856cc159f5f127d2e911f4b37bafaf31e13e00cb6a",
+      "state_root": "3ae83ec82a0f7f833388137a6eea0186339f6d1e5efcd87076264816a8109386"
+    }
+  },
+  "schema": "misaka.qi35.hardware-soak.v2",
+  "started_at_utc": "2026-07-21T04:59:36.897050Z"
+}
diff --git a/docs/evidence/reports/qi35-soak-wsl-20260721-v1.json b/docs/evidence/reports/qi35-soak-wsl-20260721-v1.json
new file mode 100644
index 0000000000000000000000000000000000000000..46d9b717c721d6767e7bc13a38e419133dbd92a4
--- /dev/null
+++ b/docs/evidence/reports/qi35-soak-wsl-20260721-v1.json
@@ -0,0 +1,773 @@
+{
+  "artifacts": {
+    "engine": {
+      "basename": "qi35_model",
+      "bytes": 4706112,
+      "sha256": "a9054eae59a083ea6f64d154c29a44d55b3e1fa3b81870409f82575205af7e4d"
+    },
+    "model": {
+      "basename": "qwen36-35b-q4km.gguf",
+      "bytes": 23938321728,
+      "sha256": "1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b"
+    },
+    "source": {
+      "basename": "qi35_model.rs",
+      "bytes": 100161,
+      "sha256": "098385055c5e1bc6a9cd6229a06a14be53e8403ea89d4f3ba9b53457c210eecd"
+    },
+    "tables": {
+      "basename": "qi35_tables.bin",
+      "bytes": 4849688,
+      "sha256": "feb22fd1864a1396b9c2bc20937f3acad79bffefdefc71c50b3747da47b64c6e"
+    }
+  },
+  "backends": [
+    {
+      "executable_sha256": "a9054eae59a083ea6f64d154c29a44d55b3e1fa3b81870409f82575205af7e4d",
+      "explicit_environment": {
+        "LD_LIBRARY_PATH": "<configured-loader-path>"
+      },
+      "flags": [],
+      "latency_seconds": {
+        "max": 7.6,
+        "median": 6.715,
+        "min": 5.87,
+        "p95": 7.34
+      },
+      "measurements": 40,
+      "name": "cpu",
+      "seconds": 266.7,
+      "stderr_tail": [
+        "SERVE_READY backend=rust-cpu-x86_64 receipts=false"
+      ],
+      "tokens": 320,
+      "tokens_per_second": 1.19985
+    }
+  ],
+  "configuration": {
+    "inherited_qi35_environment": "scrubbed",
+    "iterations": 20,
+    "max_new": 8,
+    "prompts": [
+      {
+        "ids": [
+          9419,
+          11,
+          1814
+        ],
+        "name": "hello"
+      },
+      {
+        "ids": [
+          760,
+          6511,
+          314,
+          9338,
+          369
+        ],
+        "name": "paris"
+      }
+    ],
+    "threads": 8,
+    "warmup": 2
+  },
+  "criteria": {
+    "cross_backend_execution_roots": "generated ids, FNV64, route root, KV root, and state root are identical",
+    "cross_backend_tokens": "every scheduled generated token sequence is identical",
+    "independent_host_reference": true,
+    "local_backend_count": 1,
+    "minimum_local_backends_without_reference": 2,
+    "reset_determinism": "every prompt output is invariant across iterations"
+  },
+  "finished_at_utc": "2026-07-21T03:08:08.946809Z",
+  "host": {
+    "machine": "x86_64",
+    "nvidia_gpus": [
+      "NVIDIA GeForce RTX 4060 Ti, 8.9, 610.62"
+    ],
+    "python": "3.12.3",
+    "release": "6.18.33.2-microsoft-standard-WSL2",
+    "system": "Linux"
+  },
+  "measurements": {
+    "cpu": [
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 0,
+        "prompt": "hello",
+        "seconds": 6.19,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 0,
+        "prompt": "paris",
+        "seconds": 7.16,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 1,
+        "prompt": "hello",
+        "seconds": 6.2,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 1,
+        "prompt": "paris",
+        "seconds": 7.21,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 2,
+        "prompt": "hello",
+        "seconds": 6.2,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 2,
+        "prompt": "paris",
+        "seconds": 7.03,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 3,
+        "prompt": "hello",
+        "seconds": 6.29,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 3,
+        "prompt": "paris",
+        "seconds": 7.2,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 4,
+        "prompt": "hello",
+        "seconds": 6.25,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 4,
+        "prompt": "paris",
+        "seconds": 7.18,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 5,
+        "prompt": "hello",
+        "seconds": 5.94,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 5,
+        "prompt": "paris",
+        "seconds": 7.19,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 6,
+        "prompt": "hello",
+        "seconds": 6.58,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 6,
+        "prompt": "paris",
+        "seconds": 7.24,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 7,
+        "prompt": "hello",
+        "seconds": 6.23,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 7,
+        "prompt": "paris",
+        "seconds": 6.91,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 8,
+        "prompt": "hello",
+        "seconds": 5.87,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 8,
+        "prompt": "paris",
+        "seconds": 7.26,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 9,
+        "prompt": "hello",
+        "seconds": 6.49,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 9,
+        "prompt": "paris",
+        "seconds": 7.14,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 10,
+        "prompt": "hello",
+        "seconds": 5.94,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 10,
+        "prompt": "paris",
+        "seconds": 6.86,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 11,
+        "prompt": "hello",
+        "seconds": 6.27,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 11,
+        "prompt": "paris",
+        "seconds": 7.34,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 12,
+        "prompt": "hello",
+        "seconds": 6.08,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 12,
+        "prompt": "paris",
+        "seconds": 7.06,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 13,
+        "prompt": "hello",
+        "seconds": 5.97,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 13,
+        "prompt": "paris",
+        "seconds": 7.33,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 14,
+        "prompt": "hello",
+        "seconds": 6.55,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 14,
+        "prompt": "paris",
+        "seconds": 7.02,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 15,
+        "prompt": "hello",
+        "seconds": 5.91,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 15,
+        "prompt": "paris",
+        "seconds": 6.99,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 16,
+        "prompt": "hello",
+        "seconds": 6.28,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 16,
+        "prompt": "paris",
+        "seconds": 7.36,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 17,
+        "prompt": "hello",
+        "seconds": 5.9,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 17,
+        "prompt": "paris",
+        "seconds": 6.85,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 18,
+        "prompt": "hello",
+        "seconds": 6.11,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 18,
+        "prompt": "paris",
+        "seconds": 7.6,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 19,
+        "prompt": "hello",
+        "seconds": 6.37,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 19,
+        "prompt": "paris",
+        "seconds": 7.15,
+        "tokens": 8
+      }
+    ]
+  },
+  "mismatches": [],
+  "passed": true,
+  "reference": {
+    "backend": "cpu",
+    "host": {
+      "hw.memsize": "34359738368",
+      "hw.model": "Mac13,1",
+      "machdep.cpu.brand_string": "Apple M1 Max",
+      "machine": "arm64",
+      "python": "3.14.4",
+      "release": "25.5.0",
+      "system": "Darwin"
+    },
+    "passed": true,
+    "report_sha256": "e9aaac13a82b68e7566dcc778ae5d0759c6223c0ee391c48fa6f01bffca7365e"
+  },
+  "root_check_prompt": "hello",
+  "root_checks": {
+    "cpu": {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "ids_fnv64": "ff03bf7c9a5d7593",
+      "kv_root": "b1e7b7e926aebca7cea2551b9c2945618b60ea600b1d52c2e8a843d477680254",
+      "route_root": "4ce2ca21a5ba24e388471e856cc159f5f127d2e911f4b37bafaf31e13e00cb6a",
+      "state_root": "3ae83ec82a0f7f833388137a6eea0186339f6d1e5efcd87076264816a8109386"
+    }
+  },
+  "schema": "misaka.qi35.hardware-soak.v1",
+  "started_at_utc": "2026-07-21T03:02:16.095297Z"
+}
diff --git a/docs/evidence/reports/qi35-soak-wsl-20260721-v2.json b/docs/evidence/reports/qi35-soak-wsl-20260721-v2.json
new file mode 100644
index 0000000000000000000000000000000000000000..587607e889a29a3ff50992861d5ed28ce1d58238
--- /dev/null
+++ b/docs/evidence/reports/qi35-soak-wsl-20260721-v2.json
@@ -0,0 +1,812 @@
+{
+  "artifacts": {
+    "engine": {
+      "basename": "qi35_model",
+      "bytes": 4706144,
+      "sha256": "7a015eaab4b6bab3d109afd1cf4e6e34b9f85d7d3a6ec3f9258b9a58354bd469"
+    },
+    "model": {
+      "basename": "Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+      "bytes": 23938321728,
+      "sha256": "1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b"
+    },
+    "runner": {
+      "basename": "qi35_soak.py",
+      "bytes": 38620,
+      "sha256": "977e8e39830d975c005864a5a2a5ebc2dc1c7300f8c829c21d5905c7a0e5fa7d"
+    },
+    "runtime_libraries": [],
+    "source": {
+      "basename": "qi35_model.rs",
+      "bytes": 100161,
+      "sha256": "098385055c5e1bc6a9cd6229a06a14be53e8403ea89d4f3ba9b53457c210eecd"
+    },
+    "tables": {
+      "basename": "qi35_tables.bin",
+      "bytes": 4849688,
+      "sha256": "feb22fd1864a1396b9c2bc20937f3acad79bffefdefc71c50b3747da47b64c6e"
+    }
+  },
+  "backends": [
+    {
+      "executable_sha256": "7a015eaab4b6bab3d109afd1cf4e6e34b9f85d7d3a6ec3f9258b9a58354bd469",
+      "explicit_environment": {
+        "LD_LIBRARY_PATH": "<configured-loader-path>"
+      },
+      "flags": [],
+      "latency_seconds": {
+        "max": 7.24,
+        "median": 6.4,
+        "min": 5.74,
+        "p95": 7.06
+      },
+      "measurements": 40,
+      "name": "cpu",
+      "seconds": 258.83,
+      "stderr_tail": [
+        "SERVE_READY backend=rust-cpu-x86_64 receipts=false"
+      ],
+      "tokens": 320,
+      "tokens_per_second": 1.236333
+    }
+  ],
+  "configuration": {
+    "inherited_qi35_environment": "scrubbed",
+    "iterations": 20,
+    "max_new": 8,
+    "non_system_runtime_library_count": 0,
+    "prompts": [
+      {
+        "ids": [
+          9419,
+          11,
+          1814
+        ],
+        "name": "hello"
+      },
+      {
+        "ids": [
+          760,
+          6511,
+          314,
+          9338,
+          369
+        ],
+        "name": "paris"
+      }
+    ],
+    "threads": 8,
+    "warmup": 2
+  },
+  "criteria": {
+    "artifact_provenance": "runner, backend plan, and every declared non-system runtime library are content-addressed",
+    "cross_backend_execution_roots": "generated ids, FNV64, route root, KV root, and state root are identical",
+    "cross_backend_tokens": "every scheduled generated token sequence is identical",
+    "independent_host_reference": true,
+    "local_backend_count": 1,
+    "minimum_local_backends_without_reference": 2,
+    "reset_determinism": "every prompt output is invariant across iterations"
+  },
+  "finished_at_utc": "2026-07-21T05:21:12.398136Z",
+  "host": {
+    "machine": "x86_64",
+    "python": "3.12.3",
+    "release": "6.18.33.2-microsoft-standard-WSL2",
+    "system": "Linux"
+  },
+  "measurements": {
+    "cpu": [
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 0,
+        "prompt": "hello",
+        "seconds": 6.03,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 0,
+        "prompt": "paris",
+        "seconds": 7.02,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 1,
+        "prompt": "hello",
+        "seconds": 6.1,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 1,
+        "prompt": "paris",
+        "seconds": 6.89,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 2,
+        "prompt": "hello",
+        "seconds": 5.99,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 2,
+        "prompt": "paris",
+        "seconds": 6.92,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 3,
+        "prompt": "hello",
+        "seconds": 6.02,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 3,
+        "prompt": "paris",
+        "seconds": 7.01,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 4,
+        "prompt": "hello",
+        "seconds": 5.97,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 4,
+        "prompt": "paris",
+        "seconds": 6.86,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 5,
+        "prompt": "hello",
+        "seconds": 6.02,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 5,
+        "prompt": "paris",
+        "seconds": 6.97,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 6,
+        "prompt": "hello",
+        "seconds": 6.12,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 6,
+        "prompt": "paris",
+        "seconds": 6.85,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 7,
+        "prompt": "hello",
+        "seconds": 5.82,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 7,
+        "prompt": "paris",
+        "seconds": 7.22,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 8,
+        "prompt": "hello",
+        "seconds": 6.07,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 8,
+        "prompt": "paris",
+        "seconds": 7.24,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 9,
+        "prompt": "hello",
+        "seconds": 5.98,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 9,
+        "prompt": "paris",
+        "seconds": 6.74,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 10,
+        "prompt": "hello",
+        "seconds": 6.07,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 10,
+        "prompt": "paris",
+        "seconds": 6.97,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 11,
+        "prompt": "hello",
+        "seconds": 6.13,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 11,
+        "prompt": "paris",
+        "seconds": 6.8,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 12,
+        "prompt": "hello",
+        "seconds": 5.95,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 12,
+        "prompt": "paris",
+        "seconds": 7.03,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 13,
+        "prompt": "hello",
+        "seconds": 6.0,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 13,
+        "prompt": "paris",
+        "seconds": 7.03,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 14,
+        "prompt": "hello",
+        "seconds": 6.11,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 14,
+        "prompt": "paris",
+        "seconds": 6.86,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 15,
+        "prompt": "hello",
+        "seconds": 6.02,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 15,
+        "prompt": "paris",
+        "seconds": 7.02,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 16,
+        "prompt": "hello",
+        "seconds": 6.0,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 16,
+        "prompt": "paris",
+        "seconds": 6.77,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 17,
+        "prompt": "hello",
+        "seconds": 5.74,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 17,
+        "prompt": "paris",
+        "seconds": 6.78,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 18,
+        "prompt": "hello",
+        "seconds": 6.14,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 18,
+        "prompt": "paris",
+        "seconds": 7.06,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          0,
+          198,
+          40,
+          2688,
+          264,
+          3061,
+          22839,
+          13
+        ],
+        "iteration": 19,
+        "prompt": "hello",
+        "seconds": 5.85,
+        "tokens": 8
+      },
+      {
+        "generated": [
+          11751,
+          11,
+          264,
+          3177,
+          34756,
+          364,
+          1141,
+          25438
+        ],
+        "iteration": 19,
+        "prompt": "paris",
+        "seconds": 6.66,
+        "tokens": 8
+      }
+    ]
+  },
+  "mismatches": [],
+  "passed": true,
+  "reference": {
+    "backend": "cpu",
+    "host": {
+      "hw.memsize": "34359738368",
+      "hw.model": "Mac13,1",
+      "machdep.cpu.brand_string": "Apple M1 Max",
+      "machine": "arm64",
+      "python": "3.14.4",
+      "release": "25.5.0",
+      "system": "Darwin"
+    },
+    "passed": true,
+    "report_sha256": "707455328702345f43034c7dbcbb1ab7401fcadebf61c9cbd433c221dac4ae69"
+  },
+  "reproducibility": {
+    "backend_plan": {
+      "canonical_sha256": "0aa03f1bfb9e1a8701d8441d0b2f0fc8d61bfbc053cb1bde95984649e805a181",
+      "kind": "built-in",
+      "normalized_backends": [
+        {
+          "environment": {
+            "LD_LIBRARY_PATH": "<configured-loader-path>"
+          },
+          "executable": {
+            "basename": "qi35_model",
+            "bytes": 4706144,
+            "sha256": "7a015eaab4b6bab3d109afd1cf4e6e34b9f85d7d3a6ec3f9258b9a58354bd469"
+          },
+          "flags": [],
+          "name": "cpu"
+        }
+      ],
+      "selected_backends": [
+        "cpu"
+      ]
+    },
+    "non_system_runtime_libraries": {
+      "artifacts": [],
+      "count": 0,
+      "declaration": "explicit-none-system-or-static-only"
+    },
+    "runner": {
+      "basename": "qi35_soak.py",
+      "bytes": 38620,
+      "sha256": "977e8e39830d975c005864a5a2a5ebc2dc1c7300f8c829c21d5905c7a0e5fa7d"
+    },
+    "schema": "misaka.qi35.soak-reproducibility.v1"
+  },
+  "root_check_prompt": "hello",
+  "root_checks": {
+    "cpu": {
+      "generated": [
+        0,
+        198,
+        40,
+        2688,
+        264,
+        3061,
+        22839,
+        13
+      ],
+      "ids_fnv64": "ff03bf7c9a5d7593",
+      "kv_root": "b1e7b7e926aebca7cea2551b9c2945618b60ea600b1d52c2e8a843d477680254",
+      "route_root": "4ce2ca21a5ba24e388471e856cc159f5f127d2e911f4b37bafaf31e13e00cb6a",
+      "state_root": "3ae83ec82a0f7f833388137a6eea0186339f6d1e5efcd87076264816a8109386"
+    }
+  },
+  "schema": "misaka.qi35.hardware-soak.v2",
+  "started_at_utc": "2026-07-21T05:15:14.477607Z"
+}
diff --git a/docs/evidence/workerA.txt b/docs/evidence/workerA.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dc5676ec123a1c41a9e6393dd984f1e4450224e4
--- /dev/null
+++ b/docs/evidence/workerA.txt
@@ -0,0 +1,6 @@
+backend      = Rust CPU (aarch64)
+layer-out FNV= 906729150a5a926a
+TARGET       = 906729150a5a926a
+MATCH        = YES (byte-identical to Python integer reference)
+layer[0..4]  = [202, 187, 603, -177]
+layer0.bin blake2b16 = 039f00f0a6d9fcb386624616ce197005
diff --git a/docs/evidence/workerB.txt b/docs/evidence/workerB.txt
new file mode 100644
index 0000000000000000000000000000000000000000..676ace69c3ecd19b5f00e758169d23eabc3e94cf
--- /dev/null
+++ b/docs/evidence/workerB.txt
@@ -0,0 +1,6 @@
+backend      = NVIDIA CUDA GPU (NVIDIA GeForce RTX 4060 Ti sm_89)
+block-out FNV= 906729150a5a926a
+TARGET       = 906729150a5a926a
+MATCH        = YES (byte-identical to Rust/Python reference)
+hout[0..4]   = 202 187 603 -177
+layer0.bin blake2b16 = 039f00f0a6d9fcb386624616ce197005
diff --git a/docs/p0-recalibration-rotating-sybil.md b/docs/p0-recalibration-rotating-sybil.md
new file mode 100644
index 0000000000000000000000000000000000000000..76dd7741539ba8e73442a5b2544625c883973cb0
--- /dev/null
+++ b/docs/p0-recalibration-rotating-sybil.md
@@ -0,0 +1,59 @@
+# P₀ 再較正式(回転 sybil 敵対者)— S フェーズ較正手順 §6 への追記ドラフト
+
+**日付**: 2026-07-20  **位置づけ**: node 側設計者の `pump_ev_negative` 訂正
+([ADR §5](adr-receipt-v3-node-ownership.md))を受けた、§6(S フェーズ較正手順)へそのまま貼れる追記案。
+node 側から正式版の提供があればそちらを正とする(本書はドラフト)。
+
+## 1. 敵対者モデルの差し替え
+
+- **旧**: 単一 credential が no-show を繰り返す(esc(k) が反復で増嵩し pump を抑止)。
+- **新(正)**: **回転 sybil カルテル** — min-bond の credential を β 分だけ量産し、no-show を credential
+  間で分散して**全イベントを k=0 で打つ**。esc(k) は credential 単位のため**ほぼ完全に回避**され、
+  攻撃コストは**平坦モデル**(イベント毎に基礎ペナルティ P₀ のみ)に退化する。
+- credential 量産コストは min-bond の粒度のみ。β を持つカルテルには実質無料と仮定する(保守側)。
+
+## 2. 目標状態(較正条件)
+
+esc は defense-in-depth に降格し、**平坦モデル単独で EV 負**を較正条件とする:
+
+```
+条件 (C):    N_pump × P₀  >  G_pump × (1 + μ)
+```
+
+- `N_pump` = pump に必要な no-show イベント数(市場厚み・π 経路から S フェーズで実測)
+- `G_pump` = pump 利得(現行実測: G ≈ 167k 単位)
+- 現行の平坦コスト `N_pump × P₀ ≈ 140k` → **140k < 167k で条件 (C) 違反**(ギャップ 1.19×)
+- `μ` = 安全マージン(推奨 **μ ≥ 0.25**)
+
+## 3. 再較正式
+
+```
+P₀'  =  max( P₀ × (G_pump / C_flat) × (1 + μ),  P₀ )
+     =  P₀ × 1.19 × (1 + μ)                          — 現行数値の場合
+```
+
+μ=0.25 で **P₀' ≈ 1.49 × P₀**、μ=0.10 で ≈1.31×P₀ — 提示レンジ「1.3–1.5×+余裕」と一致。
+較正は S フェーズ実測の (N_pump, G_pump) 更新のたびに再評価し、`G_pump/C_flat` 比が 1 を跨いだら
+即時に P₀ を引き上げる(引き下げは губ governance 経由のみ、即時性不要)。
+
+## 4. 整合性チェック(両立の証明義務)
+
+1. **P₀ 上限(eclipse 被害者を破滅させない)との両立**: pump に必要な no-show 数が `N_STAT` を超える
+   市場では、被害者 1 credential あたりの期待ペナルティは P₀' × (自分の no-show 数) であり、
+   pump 必要数が大きい市場ほど **必要 P₀' = G/N は小さい** → 上限と衝突しない。
+2. **薄市場**: `N_STAT` hold が π ごと凍結するため **pump 自体が不能** — 既存ガードが条件 (C) の
+   適用範囲外を塞いでいる(偶然ではなく仕事をしている)。
+3. **表現不能な悪状態**: `NoShowPenaltyDestination` に `ToRequester` を設けない型表現は維持
+   (ペナルティが攻撃者側の誰かに還流する均衡を型で排除)。
+
+## 5. テスト pin の反転
+
+- `pump_ev_negative` の敵対者モデルを**回転 sybil(全イベント k=0)**に差し替え。
+- 現行 pin `flat_cost < gain`(140k < 167k、脆弱性を固定して監視する pin)は、**P₀' 適用と同一コミットで**
+  `flat_cost > gain` へ反転させる(原子性規則: 較正と pin 反転を分離しない)。
+- esc(k) のテストは「防御の第二層が存在すること」の回帰に降格(均衡の主柱としては検証しない)。
+
+## 6. runtime 側への影響
+
+なし(経済パラメータは node 側)。runtime は receipt の no-show/k 値を正しく運ぶのみ
+([node 統合仕様](palw-node-integration-spec.md) §4 の binding が該当)。
diff --git a/docs/palw-node-integration-spec.md b/docs/palw-node-integration-spec.md
new file mode 100644
index 0000000000000000000000000000000000000000..bab577499be7e5aa7334b6e4f9598def93bfad11
--- /dev/null
+++ b/docs/palw-node-integration-spec.md
@@ -0,0 +1,234 @@
+# PALW ↔ Node 統合仕様(testnet 向け)
+
+> **⚠ SUPERSESSION(2026-07-20)**: §1–§9 の final-v7 / Ed25519 / Hash32 / ProjectionV1 記述は
+> 較正期の履歴であり実装対象ではない。現在の原本は node の
+> `mil/palw/src/receipt_v3.rs` と `mil/palw/test-data/receipt_v3_golden_v1.json`。署名は ML-DSA-87、
+> hash は keyed BLAKE2b-512 / Hash64、wire は fixed-width・宣言順・LE、照合は
+> MatchProjectionV2、`runtime_class_id` は非合意 telemetry である。runtime production encoder は
+> この node 原本へ golden-aligned 済みであり、node が runtime の旧 endian/framing を写してはならない。
+
+**対象読者**: MISAKA の **node バイナリ**を実装している方。この文書は「node が PALW compute receipt を
+**受理・検証・照合・決済**するために、どのインターフェース/フォーマット/手順を実装すれば runtime と
+噛み合うか」を定義する。runtime 側の実体は本リポジトリ(`runtime-palw/`)。
+
+> **正直な前提**: 現在 runtime が発行する receipt は `mint.eligible=false / mainnet_ready=false`
+> ([spec-snapshot §4](spec-snapshot-qwen36-2026-07-19.md))。本書は **testnet** を成立させるための
+> インターフェースを定義し、mainnet で必要だが testnet では緩められるゲートを明示する。
+
+---
+
+## 0. 全体像(データフロー)
+
+```
+worker(runtime-palw) ── issue ──▶ Receipt(署名付き) ──▶ node
+                                                        ├─ (A) stateless 検証(暗号再計算のみ、モデル非実行)
+                                                        ├─ (B) nullifier 集合で二重計上を防止
+                                                        ├─ (C) k=2 replica 照合 / audit(独立 receipt のバイト一致)
+                                                        └─ (D) 決済(testnet は簡易/mainnet は bond+slash)
+```
+
+node は **モデルを実行しない**。PALW の検証は「すでにコミットされたデータの暗号的再計算 + 独立再現の
+バイト一致」で成立する(runtime-palw `verifier.rs::verify_stateless`)。これが node 実装を軽くする鍵。
+
+---
+
+## 1. Receipt フォーマット(node が受理する単位)
+
+### 1.1 公開 receipt(JSON)
+- スキーマ: **`misaka.palw.public-receipt.v2`**(`<id>.json`)。実例は `receipts/final-v7/8e2dd34b….json`。
+- 署名エンベロープ: **Ed25519**、envelope version 1、algorithm tag 0。body を domain
+  `receipt-signature/v1` で `network_id ‖ canonical_bytes` にわたりハッシュして署名。
+- node が必ず読むフィールド(抜粋):
+  | フィールド | 型 | 用途 |
+  |---|---|---|
+  | `receipt_id` | Hash32 | 一意 id |
+  | `network_id` | Hash32 | どのネットワーク向けか(testnet/mainnet を分離) |
+  | `model_profile_id` / `runtime_class_id` / `runtime_manifest_hash` / `shape_profile_id` | Hash32 | **同一クラス判定**の束(照合の前提) |
+  | `cu_ruleset_id` | Hash32 | CU ルールセット(v3 semantic) |
+  | `canonical_compute_units` | u64 | 報酬計量(=semantic CU) |
+  | `operation_schedule_commitment` / `schedule_event_count` | Hash32 / u64 | スケジュールコミット |
+  | `gemm_trace_root` / `trace_event_count` / `trace_scheme_id` / `trace_evidence` | Hash32 … | GEMM トレース根 + 種別 |
+  | `output_commitment` | Hash32 | 出力(token)コミット = **クラス述語の核**(§2) |
+  | `request_commitment` / `job_nullifier` / `execution_nullifier` | Hash32 | 束縛と二重計上防止 |
+  | `signed_assignment_id` / `scheduler_job_id` / `worker_credential_id` / `signer_key_id` | Hash32 | 割当・作業者・署名鍵 |
+  | `replica_slot` | u8 | k=2 のスロット |
+  | `issued_epoch` / `expires_epoch` | u64 | 有効期間 |
+  | `mint`(`eligible`/`weight`/`mainnet_ready`/`class`/`ineligible_reasons`) | — | 自己申告の適格性(node は再検証する) |
+
+### 1.2 バイナリ receipt / bundle
+- `<id>.palw`(canonical 署名 receipt)、`<id>.palw.bundle`(XChaCha20-Poly1305 封緘の検証エビデンス)、
+  `<id>.complete`(完了マーカー)。node は最低限 §1.1 の公開 JSON + 署名を扱えばよく、bundle は
+  audit 時の詳細再検証に使う。
+
+---
+
+## 2. 決定性クラスと `vector_commitment`(node の照合の要)
+
+node は「**同一クラスの 2 者が同一出力をバイト一致で再現したか**」で計算の正しさを担保する(§13 の
+k=2 述語)。
+
+- **クラス**は `runtime_class_id`(= backend/microarch/量子化/モデルを束ねた id)で決まる。
+- 同一クラスの 2 receipt が `output_commitment`(token 列コミット)含む射影を**バイト一致**させれば受理。
+- **2 種の決定性モデル**(node はどちらの class 定義でも動くが、扱いが違う):
+  1. **fp per-vendor class**(現行 candle/PALW の既定): Apple/Metal, NVIDIA/CUDA(sm_89), Turing/sm_75 …
+     が**それぞれ別クラス**。同一値の再現は同一 microarch + 同一 toolchain 版に限る(fp は脆い:
+     candle 版・CUDA 版の差で値が動く — 実測済み)。→ node は class を細かく分ける。
+  2. **canonical-integer class**(本リポジトリで構築中、[canonical-integer-compute-design](canonical-integer-compute-design.md)):
+     整数計算で **CPU/Metal/CUDA/ROCm を跨いで同一ビット**。実 attention ブロックで実証済み
+     (`dea9a75b…`, [4b-2b evidence](evidence/canonical-int-attention-4b2b-2026-07-19.md))。→ node は
+     **これを 1 つの vendor 非依存クラス**として扱え、k=2 を**異ベンダ間**で組める(より強い保証)。
+
+> **node への含意**: `runtime_class_id` を不透明 id として扱い、`published.json` 相当の
+> **class レジストリ**(class_id → 期待 `vector_commitment`/ポリシー)を参照する設計にすること。
+> fp class は多数・整数 class は少数(理想は 1)になる。
+
+---
+
+## 3. Receipt 検証手順(node が実装する A: stateless)
+
+runtime-palw `verify_stateless` と**同一の再計算**を node 側でも実装する(モデル実行なし):
+
+1. **署名**: Ed25519 検証。弱鍵/small-order 拒否、`signer_key_id` 一致。
+2. **nullifier 再導出**: `job_nullifier` / `execution_nullifier` を規定の domain で再計算し一致確認。
+3. **schedule 整合**: `operation_schedule_commitment` のハッシュ連鎖を `schedule_event_count` 個で再計算。
+4. **CU 再計算**: committed CU ルール(`cu_ruleset_id`)で canonical CU を再計算し `canonical_compute_units`
+   と一致(v3 semantic は「モデル構造 + token 数」から算出、graph 非依存)。
+5. **GEMM trace 根**: `gemm_trace_root` のハッシュ連鎖 + `trace_event_count` + `trace_evidence` 種別 +
+   capability を照合。
+6. **output/prompt コミット**: 呼び出し側が供給する `OutputOpening`(prompt token ids + 出力)を再ハッシュ
+   し `output_commitment` / prompt コミットに一致、token 数が `prefill_tokens`/`decode_tokens` に一致。
+7. **mint 再評価**: `mint` ブロックを自前で再計算(node は worker の自己申告を信じない)。
+
+いずれか不一致で receipt 却下。**注意**: 検証は「与えられた出力のハッシュ一致」であって node がモデルを
+回すわけではない。真の計算保証は §4 の k=2 で担保。
+
+---
+
+## 4. k=2 レプリカ照合と audit(node が実装する C)
+
+- **matching**: 同一ジョブに割り当てた 2 worker の receipt について、`MatchProjectionV1`(下記フィールドの
+  射影)が**バイト一致**するかを照合。runtime-palw `matcher.rs` と同じ射影・順序で実装:
+  `job_nullifier, request_commitment, model_profile_id, runtime_class_id, runtime_manifest_hash,
+  shape_profile_id, cu_ruleset_id, canonical_compute_units, prefill_tokens, decode_tokens,
+  operation_schedule_commitment, schedule_event_count, output_commitment, trace_scheme_id,
+  gemm_trace_root, trace_event_count`。
+- **binding 検査**(`audit.rs::validate_bindings`): 2 receipt は `receipt_id / execution_nullifier /
+  signed_assignment_id / runtime_instance / signer / worker / owner` が**相異**、かつ
+  `network_id / scheduler_job_id / job_nullifier / request_commitment` が**同一**であること。
+- **audit-replay**: 疑義時、独立 worker に再実行させ `MatchProjectionV1` バイト一致を確認
+  (`audit-replay-result/v1`)。**canonical-integer class なら異ベンダ再実行でも一致するので、談合耐性が上がる**。
+
+---
+
+## 5. node が保持すべき状態(mainnet ゲート = testnet で一部緩和)
+
+runtime-palw `mint.rs::assess_mainnet_readiness` が列挙するゲートが、そのまま node の責務一覧になる:
+
+| ゲート | node の責務 | testnet での扱い |
+|---|---|---|
+| `network.challenge_binding` | epoch beacon を発行し、receipt が fresh challenge を束縛しているか検証 | **簡易 beacon 可**(固定/低頻度) |
+| `network.global_nullifier` | ネットワーク全体の nullifier 集合で cross-node 二重計上を防止 | **必要**(testnet でも二重計上防止は要る) |
+| `network.anchored_assignment` | 割当・scheduler 鍵・credential 有効性を deployed authority に対して証明 | **簡易 authority 可**(単一/信頼) |
+| `network.bonded_credential` | ephemeral 署名鍵が persistent bonded worker credential に委譲されているか | **testnet は bond 額 0 / stub 可** |
+| `network.consensus_registry` | CU ルールセット + evidence ポリシーが chain governance に登録され mint weight を持つ | **testnet genesis に固定値** |
+| `hardware.cross_device_conformance` | 複数 GPU 世代で token 一致(クラス確立) | **canonical-integer なら 1 実装で満たしやすい**(§2) |
+| `model.official_genesis` | canonical モデルが公式重みからの決定的 Genesis GGUF + 2 者再現性 | **testnet は現行 abliterated 変換で可**、mainnet で要差し替え |
+
+**testnet の最小成立条件**: 署名検証 + stateless 検証(§3)+ global nullifier(二重計上防止)+ k=2 照合
+(§4)+ 簡易 challenge/authority。bond/slash/官製 Genesis は stub でよい。
+
+---
+
+## 6. 決済(node が実装する D)
+
+- 型は runtime-palw に存在: `external_authority.rs`(escrow/settlement/`protocol_fee: u64`/payout)、
+  `bond.rs` / `bond_authority.rs` / `slash_proof.rs`(`SlashReason`:
+  CanaryFailure/AuditMismatch/AuditTimeout/InvalidManifest/Equivocation/DuplicateExecution)。
+- **testnet**: `protocol_fee` と payout をテスト通貨で回し、escrow は `None`(self_local)か固定額。
+  slash は AuditMismatch/DuplicateExecution だけ有効化すれば十分。
+- **mainnet**: escrow の c_A 係留・reroll 壁など経済設計は
+  [spec-snapshot §6.4](spec-snapshot-qwen36-2026-07-19.md)(**未実装**)を参照。
+
+---
+
+## 7. node 実装チェックリスト(testnet)
+
+- [ ] `misaka.palw.public-receipt.v2` の JSON パーサ + Ed25519 署名検証。
+- [ ] §3 の stateless 再計算(nullifier / schedule chain / CU / trace root / output commit / mint 再評価)。
+      **runtime-palw の domain タグ・ハッシュ順序を 1 bit も違わず移植すること**(不一致は誤 FAIL の元)。
+- [ ] class レジストリ(`runtime_class_id` → 期待 `vector_commitment`/ポリシー、fp は多数・整数は少数)。
+- [ ] global nullifier 集合(cross-node 二重計上防止)。
+- [ ] k=2 `MatchProjectionV1` 照合 + `validate_bindings`(§4)。
+- [ ] 簡易 challenge/beacon + 簡易 authority(§5 testnet 列)。
+- [ ] テスト決済(protocol_fee/payout、AuditMismatch/DuplicateExecution の slash)。
+- [ ] `network_id` で testnet/mainnet を厳密分離。
+
+---
+
+## 8. 正直な現状(runtime 側の実装/未実装)
+
+- **実装済み(runtime-palw)**: receipt v2 発行 + 署名、`verify_stateless`、k=2 `MatchProjectionV1` 照合、
+  audit-replay 比較、mint 自己申告 + 再評価、semantic CU v3、Metal kernel-level trace。→ **node は
+  これらの検証ロジックをミラーするだけでよい**(サーバ権威やモデル実行は不要)。
+- **未実装(= node 側 or 外部で新規に必要)**: deployed network authority / global nullifier サービス /
+  epoch beacon / bond authority / consensus registry / 官製 Genesis。**これらが testnet で node が
+  新規に立てる部分**(mainnet はさらに KMS・多世代 HW が要る)。
+- **進行中(canonical-integer)**: vendor 非依存の整数クラス。完成すれば §2 の class 数が激減し、
+  `hardware.cross_device_conformance` が構造的に満たされる。node は「fp 多クラス」と「整数 1 クラス」の
+  両対応で設計しておくと移行が楽。
+
+---
+
+## 9. インターフェース参照
+
+- Receipt v3 の真実源: node `mil/palw/src/receipt_v3.rs`。
+- cross-repository golden: node `mil/palw/test-data/receipt_v3_golden_v1.json` と runtime
+  `runtime-palw/src/receipt_v3.rs::node_owned_receipt_v3_golden_vector_matches_qwen_crypto_stack`。
+- 決定性クラスの背景: [canonical-integer-compute-design.md](canonical-integer-compute-design.md) と
+  [4b-2b evidence](evidence/canonical-int-attention-4b2b-2026-07-19.md)。
+
+> node 実装者へ: node-owned Receipt v3 を変更する場合は node fixture を先に更新し、runtime production
+> encoder が同じ body/digest/pair-idへ一致することを確認する。規約の流れは常に node → runtime である。
+
+---
+
+## 10. T-shared(共有 testnet)— LLM/worker 側実装(2026-07-20 追記、実装済み)
+
+`runtime-palw/src/testnet.rs`(+ `receipt_v3.rs`)が T-shared の worker 側全ピースを提供する:
+
+- **共有 JobSpec**(`JobSpecV2` / `misaka.palw.testnet-jobspec.v2`): seeder/scheduler が配布する JSON — `network_id / compute_set_id /
+  job_challenge / prompt_token_count / replica_slot / epochs`。**worker は consensus フィールドの乱数を一切自前で作らない**
+  (これが 2 worker のレシートを matchable にする — 較正期バイナリの構造的 unmatchable 問題の解)。
+- **発行**: `flow::issue_receipt_v3(spec, result, credential, seed)` — 整数 canonical 実行の roots +
+  token 列から `ComputeReceiptV3` を構築し **ML-DSA-87 署名**(output_commitment は job_challenge 束縛の
+  keyed BLAKE2b-512)。
+- **提出形式**: `export_receipt` / `import_receipt` — schema `misaka.palw.testnet-submission.v3`
+  (receipt + envelope + verifying key、全て hex)。**import は ML-DSA-87 以外の algorithm tag を
+  受け付けない**(Ed25519 は提出形式レベルで表現不能)。
+- **store**: `store_receipt` / `load_receipts`(receipt_id 名の JSON ファイル、testnet-grade)。
+- **node 側等価の消費**: `flow::receive_and_match(a, b, expected_a, expected_b)` — node/selected-chain が
+  独立に供給した `ReceiptV3Expectations`(network / compute set / challenge / slot / issue-expiry-current epoch /
+  registered credential)で両 envelope を検証してから k=2 predicate を評価する。low-level `match_pair_v3`
+  と self-consistency verification は artifact 診断用であり admission verdict ではない。
+- テスト: フルラウンドトリップ(spec 共有 → 2 worker 発行 → export/import → store → verify+match)+
+  拒否系(出力分岐 / sybil 自己ペア / 改竄 / algorithm 偽装)。
+
+node 側が実装するのは: seeder(spec 配布)、submission 受信 transport、global nullifier、決済 — §5 の
+testnet 列のとおり。worker 側はこのモジュールで完結。
+
+### §10.1 worker CLI — 起動時モード選択(2026-07-20 追記、実装済み)
+
+`palw-worker`(`runtime-palw`、feature `ml-dsa`、`cargo build --release --features ml-dsa --bin palw-worker`)
+は起動時に **自家発注ジョブ / 検証** を選択する:
+
+- **TTY では対話選択**(`--mode` 省略時): `[1] 自家発注ジョブ (self-job) / [2] 検証 (verify)`。
+  非 TTY では `--mode self-job|verify` 必須(fail-closed)。
+- **self-job(自家発注)**: 新しい `JobSpecV2` を mint(slot 0、challenge は OS entropy)→ 実行結果
+  (`--result` JSON: tokens + roots、integer-canonical runner の出力)から v3 receipt を発行・ML-DSA 署名
+  → store へ保存 + **検証者向け spec**(slot 1)を書き出し。
+- **verify(検証)**: 配布 spec(`--spec`、slot は強制 1)+ 相手 submission(`--peer`)を読み、
+  **自分の再計算結果**から自 receipt を発行 → 両 envelope の self-consistency 検証 + low-level k=2 predicate →
+  `local k2 = MATCHED/REJECTED (NON-ADMISSION)`。これはローカル診断であり、network admission は別途
+  node が registry/selected-chain 由来 `ReceiptV3Expectations` を `flow::receive_and_match` へ渡して行う。
+- スモーク実証済み: 自家発注 → クロスクラス検証 MATCHED(order 不変 pair_id)/ token 分岐 →
+  `ProjectionMismatch("output_commitment")` で REJECTED / 非 TTY ガード。
diff --git a/docs/receipt-v3-ledger.md b/docs/receipt-v3-ledger.md
new file mode 100644
index 0000000000000000000000000000000000000000..7584cdbbad61dac84d342681b5d43cbba477a14c
--- /dev/null
+++ b/docs/receipt-v3-ledger.md
@@ -0,0 +1,111 @@
+# Receipt v3 — runtime-palw 移行台帳と node-owned wire 境界
+
+**日付**: 2026-07-20  **位置づけ**: [ADR Receipt v3](adr-receipt-v3-node-ownership.md) の移行前台帳と、
+移行後の Receipt v3 境界を記録する履歴資料。§0–§6 は旧 runtime-palw 実装の inventory であり、
+現行 Receipt v3 の wire/hash 仕様ではない。現行仕様の正本は node の
+`mil/palw/src/receipt_v3.rs` と `consensus/core/src/signature_domains.rs` で、runtime はその golden
+fixture に byte-for-byte 追従する。
+
+## 0. 移行前の core 構成(履歴 inventory)
+
+- 移行前の `domain_hash(domain, schema_version, parts)` @ `commitment.rs:280-289` は
+  **SHA3-256 / 32B**(`Hash32` 定義
+  は `commitment.rs:7` の 1 箇所)。構成: `write_bytes(b"MISAKA/PALW")`(u64-BE 長前置)→ `write_str(tag)`
+  → `write_u16(schema_version)`(BE、長前置なし)→ 各 part を u64-BE 長前置 — prefix-free。
+  という構成だった。これは移行対象の把握に使った記録であり、Receipt v3 の canonical framing
+  ではない。
+- **手書き例外(見落とし厳禁)**: `artifact.rs:85-123` が同じ framing を streaming 用に**手で再実装**
+  (`model-artifact-leaf/v1`)。`domain_hash` を差し替えてもここは SHA3 のまま残る — 個別移行必須。
+- 署名は全て Ed25519(`ed25519_dalek`、alg tag `0`)で、署名対象は常に 32B の `domain_hash` digest。
+
+## 1. Consensus 行(node 台帳へ昇格)— 集計
+
+エージェント精査の結果(148 hash site + 17 署名 site)。主要グループと代表 tag のみ列挙(完全リストは
+精査ログどおり。**全行 file:line 付きで確認済み**):
+
+| グループ | 代表 tag(件数) | 例 file:line |
+|---|---|---|
+| core コミット/nullifier | `prompt/v1` `output/v1` `owner/v1` `request/v1` `job-nullifier/v1` `execution-nullifier/v1`(6) | commitment.rs:361-473 |
+| receipt v1/v2 | `receipt-signature/v1,v2` `receipt-body/v1,v2` `receipt-id/v1,v2` `signer-key/v1` ほか(10) | receipt.rs / protocol_v2.rs |
+| job/assignment v1/v2 | `job-request/v1,v2` `assignment/v1,v2` ほか(5) | job.rs / protocol_v2.rs |
+| schedule/trace 連鎖 | `schedule-{init,step,final}/v1` `gemm-trace-{scheme,init,step,final}/v1`(7) | scheduler.rs / trace.rs |
+| semantic CU/schedule | `qwen36-semantic-schedule/v1` `qwen36-semantic-cu/v3` `cu-ruleset/v1..v3`(5) | semantic_*.rs / compute_units.rs |
+| adapter(route/kernel) | `qwen36-expert-route-chain/v1` `qwen36-metal-kernel/v1` mapping 系(7) | qwen_adapter.rs |
+| manifest/profile 同定 | `model-profile/v1` `runtime-class/v1`⚠ `shape-profile/v1` `runtime-manifest/v1,v2` + qwen_profile 系 12 tag × **2 builder copy**(~19) | manifest.rs / qwen_profile.rs |
+| deterministic 実行 | `lora-set/v1` 等(5) | deterministic.rs |
+| artifact Merkle | `model-artifact-{leaf,node}/v1`(2、leaf は手書き実装) | artifact.rs |
+| matcher/state 遷移 | `replica-match/v1` `pair-id/v1` + state_store の proof/release 系(~18) | matcher.rs / state_store.rs |
+| audit/canary/bond/slash | `audit-*` `canary-*` `bond-*` `slash-*`(~15) | audit.rs / canary.rs / bond*.rs / slash_proof.rs |
+| CUDA attestation/trace | `cuda-*` pinned 系含む(~26) | cuda_*.rs |
+| external 経済 | `external-*`(8) | external*.rs |
+| beacon/ticket | `future-beacon/v1` `work-ticket/v2` `local-maturity-basis/v2`⚠(3) | future_beacon.rs / work_ticket.rs |
+
+⚠ 特記: (a) `runtime-class/v1` は現行 consensus だが **ADR §3 で ImplementationTelemetry へ降格** —
+台帳には「consensus 集合から離脱する行」として登録。(b) `local-maturity-basis/v2` は名前に反し
+`work-ticket/v2` に折り込まれる **consensus 行**。(c) 重複 tag は**再計算 site ごと**に行が要る
+(`request/v1`×2、`replica-match/v1`+`pair-id/v1`×matcher/state_store、`work-ticket/v2`×2、
+`canary-precommit/v1`×2)。
+
+## 2. LOCAL 行(Hash64 consensus 移行から**除外**)
+
+`verification-bundle-*`(v1+v2 全部: id/receipt/public/AAD/AEAD-key)、`sqlite-schema/v2`、
+`PALW_SQLITE_MASTER_V4`(state_store.rs:1215 の raw SHA3 — tag 名前空間外の第 2 SHA3 site)、
+参照バイナリの entropy id 生成(`scheduler-job-id/v1` 等)、`sha256_file` / receipt-set manifest の
+SHA-256 tooling。
+
+## 3. 署名 site(全 17 → ML-DSA-87 へ、Ed25519 は feature-gate-out)
+
+SignedReceiptV1/V2、SignedJobRequestV1/V2、SignedAssignmentV1/V2、SignedCanaryPrecommitV1、
+SignedBondFundingAttestationV1、SignedSlashAppealV1、SignedSlashDecisionV1、
+SignedCudaTranscriptAttestationV1/V2、SignedExternalFundingAttestationV1、
+SignedExternalDemandWeightGrantV1、SignedExternalTerminalConfirmationV1、SignedFutureBeaconV1、
++ 参照バイナリ。全て「32B digest に署名」構造なので、**v3 では Hash64 digest + ML-DSA-87 署名**に
+一斉置換(envelope の alg tag を新設、`0`=Ed25519 は legacy feature でのみ有効)。
+
+## 4. 移行サイジング(Hash32→Hash64)
+
+`: Hash32` フィールド概数: state_store 146 / external_authority 104 / bond_authority 88 /
+protocol_v2 81(55 fields) / audit 65 / canary 58 / cuda_attestation_v3 50 / cuda_trace_v3 43 /
+receipt 24(18 fields) / matcher 23 / verifier 29 / manifest 25 …。型 alias が 1 箇所
+(`commitment.rs:7`)なので **alias 切替 + 直列化長 + 検証側の期待長**が主作業。
+`read_array_64`(commitment.rs:199)は既存(Ed25519 sig 用)で流用可能。
+
+## 5. 依存関係(Cargo)
+
+- **blake2 系 dep は現在無い** → keyed BLAKE2b-512 に `blake2` crate(または `blake2b_simd`)を追加
+  (MSRV 1.81 / edition 2021 / `unsafe_code=forbid` 適合を確認のこと)。
+- ML-DSA-87: RustCrypto `ml-dsa`(FIPS 204)等の pre-1.0 crate を要選定 — **MSRV/unsafe/監査状況の
+  確認が必要**(この選定は node 側と共通化するのが台帳一本化と同じ理屈で必須)。
+- 現行: sha3(consensus)、sha2(local)、ed25519-dalek(gate-out 対象)、chacha20poly1305(local
+  bundle)、zeroize/base64ct(MSRV pin)。
+
+## 6. 精査での訂正 1 件
+
+エージェント報告の「mint.rs が存在しない」は**誤り** — `runtime-palw/src/mint.rs` は存在し
+(`assess_mint_eligibility` / `assess_mainnet_readiness`)、ADR の「mint 経路の署名方式ゲート」は
+ここに実装する(検証済み)。
+
+## 7. 追記 (2026-07-20 後刻) — 移行後の Receipt v3 と runtime-local domain
+
+`palw-integer-receipt` / `palw-verify-integer` は整数エンジンの実行結果から node-owned Receipt v3
+projection/body を組み立てる。wire body は field declaration order の固定幅 little-endian、receipt
+hash は下表の node-owned domain を key にした BLAKE2b-512 であり、runtime 独自 framing を仕様化
+しない。ML-DSA-87 context も node 台帳の `misaka-palw-v3/receipt/mldsa87` を使用する。
+
+| domain | 所有/分類 | 用途 |
+|---|---|---|
+| `misaka-palw-v3/projection` | node / Receipt v3 | canonical projection digest |
+| `misaka-palw-v3/receipt-signing` | node / Receipt v3 | canonical receipt body の署名 digest |
+| `misaka-palw-v3/receipt-id` | node / Receipt v3 | signing digest からの receipt id |
+| `misaka-palw-v3/execution-nullifier` | node / Receipt v3 | credential・job・slot・projection に結び付く nullifier |
+| `misaka-palw-v3/output` | node / Receipt v3 | canonical `u32` token 列の output commitment |
+| `misaka-palw-v3/pair-id` | node / Receipt v3 | 検証済み独立 receipt pair の id |
+| unkeyed BLAKE2b-512(`validator_id_from_pubkey`) | node / registry identity | ML-DSA-87 verification key から credential id を導出 |
+| `qi35-network/v3` `qi35-prompt/v3` | runtime-local execution input | network / sealed prompt commitment を生成し projection field へ渡す |
+| `qi35-compute-set/v3` `qi35-self-challenge/v3` `qi35-schedule/v3` | runtime-local execution input | model/table/ruleset、job challenge、決定的 schedule の生成 |
+| `qi35-exec-{route,kv,state}/v3` | runtime-local execution root | 整数エンジンの bit-exact route/KV/DeltaNet state digest |
+| `qi35-mldsa-seed/v1` `qi35-bundle-key/v1` `qi35-bundle-nonce/v1` | LOCAL(台帳外) | 鍵導出・bundle 封緘(秘密材料、consensus 非対象) |
+
+旧 `qi35-*`(チャット版 keyed-blake2b-256 MAC receipt、`qi35_model.rs` 内 `qi35-receipt/v0` 系)は
+**プロトタイプ扱い**で台帳非昇格。`qi35-output/v3`、`qi35-credential/v3`、
+`qi35-nullifier/v3` も Receipt v3 の正本ではなく、上表の node-owned 関数へ置換済み。
diff --git a/docs/spec-snapshot-qwen36-2026-07-19.md b/docs/spec-snapshot-qwen36-2026-07-19.md
new file mode 100644
index 0000000000000000000000000000000000000000..f9a8a064b0307d864bf5c9e584452666b13744cd
--- /dev/null
+++ b/docs/spec-snapshot-qwen36-2026-07-19.md
@@ -0,0 +1,185 @@
+# PALW / Canonical Compute — 現行仕様スナップショット (Qwen3.6-35B-A3B)
+
+**日付**: 2026-07-19  **対象**: MISAKA PALW receipt runtime（このリポジトリ）
+**基準レシート**: `receipts/final-v7/8e2dd34b7609d6d7aeec17bff485eb1ae4db31f66dd899a3c3a3e671656053f9`
+
+---
+
+## 0. この文書の読み方（実装済み ⇔ 提案中 の境界）
+
+この文書は **2 部構成**。混同すると事実誤認になるので最初に線を引く。
+
+- **第 I 部（§1–§5）= 現行仕様**。いまリポジトリのコードに存在し、Metal 実機で発行・再検証まで到達している内容。値はすべて上記 final-v7 レシートまたはソース（`file:line`）に紐づく。
+- **第 II 部（§6–§7）= 設計提案**。直近の設計分析（DeltaNet 一致条件 / A 側粗粒度コミット / B 側 teacher-forced prefill / escrow 再較正）が **追加で要求する** 仕様。**現時点ではコードに未実装**。各項目に現行コード上の実際の状態を併記する。
+
+> 一言で言うと: **現行は「暗号的コミットの束縛と再計算」まで。第 II 部の「検証時にモデルを prefill で再実行して照合する」機構・checkpoint 連鎖・整数 MoE/DeltaNet 意味論・escrow 経済パラメータは、まだ 1 行も存在しない。**
+
+---
+
+# 第 I 部 — 現行仕様（実装済み・Metal 実機検証済み）
+
+## 1. モデル同定（現行 pin）
+
+現行の正準モデルは **ハイブリッド Qwen3.6-35B-A3B**（旧 dense Qwen3-8B は legacy パスとしてコードに残るが非現行）。
+
+| 項目 | 値 | 強制箇所 |
+|---|---|---|
+| pin schema | `misaka.palw.model-profile-pin.v2` | — |
+| profile 名 | `Qwen3.6-35B-A3B-Claude-4.7-Opus-abliterated-Q4_K_M-Metal-arm64` | — |
+| HF architecture | `Qwen3_5MoeForConditionalGeneration` | `qwen_profile.rs:633-635` |
+| model_type / GGUF arch | `qwen3_5_moe` / `qwen35moe` | 同上・`qwen_adapter.rs:1920` |
+| topology | `MixtureOfExperts` | `qwen_profile.rs:531` |
+| 層数 | **40** | `qwen_profile.rs:638` |
+| hidden | **2048** | `qwen_profile.rs:636` |
+| attention heads / KV heads / head_dim | 16 / 2 / 256 | `qwen_profile.rs:637-641` |
+| full_attention_interval | 4（→ full-attn 層は 3,7,…,39 の 10 層、残り 30 層は gated-delta-net） | `semantic_schedule.rs:69-71` |
+| DeltaNet: key/value head_dim, key/value heads, conv kernel | 128 / 128, 16 / 32, 4 | `profile.json:18-22`（範囲検査はされない） |
+| MoE: expert_count / top-k / 専門家中間次元 / shared | 256 / 8 / 512 / 512 | `qwen_profile.rs:642-643`（512 は検査対象外） |
+| vocab | **248320** | `qwen_profile.rs:644` |
+| native context | 262144（実行時は `FIXED_CONTEXT_TOKENS=4096` にクランプ） | `qwen_profile.rs:645, 33` |
+| rope_theta / partial_rotary | 10000000 / 0.25 | `qwen_profile.rs:643`・`profile.json:24` |
+| 量子化 / base dtype | Q4_K_M（file_type 15）/ bfloat16 | `qwen_profile.rs:646-647` |
+| GGUF sha256 | `1dc494614bee8a3bc00e79fe5a49da0fc1c36b3b118c4156e223e98e5a0a671b` | `require_sha256` `qwen_profile.rs:396-400` |
+| GGUF bytes | 23938321728（≈23.9GB） | — |
+| 入手元 | Ollama `registry.ollama.ai/huihui_ai/Qwen3.6-abliterated` tag `35b-Claude-4.7` | `profile.json:66-69` |
+| base HF repo / rev | `huihui-ai/Huihui-Qwen3.6-35B-A3B-Claude-4.7-Opus-abliterated` / `ac18882735d037f6074a7630eb68d85db8234c25` | `profile.json:31-32` |
+| llama.cpp commit | `12127defda4f41b7679cb2477a4b0d65ee6a0c8f`（build 10015）+ PALW パッチ sha256 `d155a88b…e2f9e02c` | — |
+
+> 注意（正直さ）: このモデルは **第三者 abliterated 変換**であり、公式 upstream からの決定論的 Genesis GGUF ではない。これは `model.official_genesis` ゲート未達の直接原因（§4）。
+
+## 2. 整数正準計算 — CU ruleset v3（semantic）
+
+現行の正準 CU は **v3（semantic / graph 非依存 / fragmentation-proof）**。
+
+- CU ruleset は **v1 / v2 / v3 のみ**受理（`compute_units.rs:624-631`）。**committed / mint-grade は v3**。
+- v3 の `cost()` は **全オペで `Ok(0)`**（`compute_units.rs:702-708`）。観測スケジュールは順序コミットとしてのみ保持し、compute 重みを持たない。正準 CU 総量は `crate::semantic_cu`（モデル構造 + token 数から算出）。final-v7 での値は **`canonical_compute_units = semantic_compute_units_v3 = 41692`**、`cu_ruleset_id = 43a5feef177b389f976361b22ac9d57da65815261282005bc78d1666a37870ce`。
+- `ComputeOperation` は 21 variant（`Gemm=0 … Elementwise=20`）。ハイブリッド専用の `ExpertGemm=15/SsmConv=16/GatedDeltaNet=17/L2Norm=18/Reduction=19/Elementwise=20` を追加済み。**v1/v2 はこれらで fail-closed**（"requires semantic ruleset v3"）。v1 は `Generic` を拒否。
+- 正準スケジュールは `qwen36_semantic_schedule(prefill, decode)` が生成し、`qwen36-semantic-schedule/v1` で domain-hash してコミット（`semantic_schedule.rs:223`）。final-v7: `total_ops=764`（gemm=82, attention=20, expert_route=80, forward_passes=2）, `commitment=e6fc731e…`。
+
+> 正直な限界（§5 と重複）: このスケジュールは **構造テンプレート**であり、MoE の top-k は「experts=256 / top_k=8 + 要素数」という**整数パラメータとしての記録**であって、router logits に対する実 argmax/top-k 選択アルゴリズムは v3 側には実装されていない。delta-net ステップは要素数のみを持つ `Generic` op（`SsmConv/GatedDeltaNet` variant は語彙に**宣言のみ**で committed schedule は使わない）。gate/exp/sigmoid/SiLU/conv1d の **LUT は未実装**。
+
+## 3. スケジュール / トレース / 検証機構
+
+### 3.1 観測（証跡の生成側）
+- observer（`vendor/llama.cpp/tools/palw-observer/palw-observer.cpp`）は **強制 greedy（temp=0）, n_batch=n_ubatch=n_seq_max=1, 1 thread, flash-attn off**。prefill / decode とも **1 token ずつ `llama_decode`**。
+- sketch モードで dense GEMM（`GGML_OP_MUL_MAT` のみ）に対し出力の sign+magnitude-bucket sketch（先頭 64 要素 → 256-bit）。
+- **Metal kernel-dispatch 束縛**: `ggml_metal_palw_set_dispatch_hook` が各 Metal dispatch（pipeline 名 + threadgroup 幾何）を記録し、各 GEMM を「ASK→POST 窓内の最後の matmul dispatch（`mul_mv`/`mul_mm` かつ非 `_id`）」に 1:1 で帰属。**これは launch-geometry + 出力 sketch の束縛であり、CUDA の intra-kernel accumulator sketch ではない**（正直ラベル）。
+- **MoE routing**: `ffn_moe_topk` の I32 Top-K 選択テンソルを読み戻し、**実際の選択専門家 index** を `route` レコードとして emit（observer schema v2）。final-v7: `route_event_count=240`, `expert_route.root=5e4ea70b…`。
+
+### 3.2 検証（**重要**）
+現行の `verify_stateless`（`verifier.rs:219-364`）は **モデルを decode でも prefill でも一切再実行しない**。純粋な暗号的再計算のみ:
+1. job/execution nullifier を再導出、
+2. operation-schedule hash chain を `verify_integrity` で再計算、
+3. スケジュールを `ComputeUnitCounter` で歩いて正準 CU を再計算、
+4. GEMM trace hash chain の root/count/evidence_kind/scheme + capability を照合、
+5. 呼び出し側が供給する `OutputOpening`（prompt token ids + 出力）を再ハッシュして `output_commitment` / `prompt_commitment` に一致するか、token 数が prefill/decode に一致するかを検査、
+6. Ed25519 署名検証。
+
+> つまり **出力は検証器に「与えられ」、ハッシュ一致だけを見る**。唯一の「再実行」概念は future-audit / k=2 マッチング（`audit.rs`/`matcher.rs`）で、これは **別の独立ワーカーが自前でフルレシートを再生成**し、両者の `MatchProjectionV1` コミット射影がバイト一致するかを比べるもの。検証器内でのモデル replay ではない。
+
+### 3.3 トレース evidence
+`TraceEvidenceKind`: `Absent=0, GraphFallback=1, KernelSketch=2, MetalKernel=3`。**現行 Metal レシートは `MetalKernel=3`**（`trace_evidence="metal_kernel"`）。CUDA の `KernelSketch=2` は型としては存在するが本 Metal ビルドでは生成されず、検証時に receipt v1 では拒否（`CudaKernelSketchRequiresReceiptV2`）。
+
+## 4. レシート構造とゲート状態（final-v7）
+
+- **schema**: `misaka.palw.public-receipt.v2`。署名は Ed25519（envelope v1）。
+- **主要値**: `evidence_level=gemm_traced`, `job_class=self_local`, `prefill_tokens=5`, `decode_tokens=2`, `observer_summary.canonical_operations=13770`, `trace_event_count=2466`。
+- **mint（正直な現状）**: `eligible=false`, `mainnet_ready=false`, `weight=0`, `class=local_self_consistent_v0_1`。`ineligible_reasons`（3 件、逐語）:
+  1. trace is a Metal kernel-launch-bound sketch, not an intra-kernel accumulator proof
+  2. assignment is an embedded local snapshot, not a network-anchored challenge-bound assignment
+  3. signing identity is ephemeral and not bonded to a persistent worker credential
+
+### mainnet readiness ゲート（12 個中 **3 Met / 9 blocking**）
+
+| ゲート | 状態 | ブロッカー種別 |
+|---|---|---|
+| compute.semantic_cu | **Met** | — |
+| compute.no_generic_pricing | **Met** | — |
+| compute.kernel_level_trace | **Met** | — |
+| compute.expert_route_trace | Not Met | `InRepoPending` |
+| compute.semantic_schedule_match | Not Met | `InRepoPending` |
+| network.challenge_binding | Not Met | ExternalNetwork |
+| network.global_nullifier | Not Met | ExternalNetwork |
+| network.anchored_assignment | Not Met | ExternalNetwork |
+| network.bonded_credential | Not Met | ExternalNetwork |
+| network.consensus_registry | Not Met | ExternalNetwork |
+| hardware.cross_device_conformance | Not Met | ExternalHardware |
+| model.official_genesis | Not Met | ExternalModelGenesis |
+
+> 補足: `expert_route_trace` と `semantic_schedule_match` は、レシートが実際に `expert_route`（240 件）と `semantic_schedule` commitment を**運んでいる**にもかかわらず、ゲートがまだそれらを**消費していない**ため `InRepoPending`（`mint.rs:186,190`）。ここは第 II 部の提案とは別の、純粋に in-repo で閉じられる 2 項目。
+
+## 5. 現行の正直な限界（要約）
+
+- 検証はモデル再実行を含まない（§3.2）。k=2 一致は「独立再生成のバイト一致」で担保。
+- Metal `metal_kernel` は launch-geometry 束縛であって CUDA-V3 相当の intra-kernel accumulator 証明ではない。
+- MoE 整数 top-k / DeltaNet per-token 再量子化 / LUT 群は **未実装**（§2 の注記）。
+- escrow / bond / slash 型は存在するが self_local レシートでは `external_escrow_reference=None`（非活性）。
+- モデルは abliterated 第三者変換で official Genesis ではない。
+- ドキュメント drift（要反映）: `requirements.md` は依然 final-v6 `eb51b08c…` を canonical と記載、テスト数も runbook=224 / requirements=242 で不一致。本スナップショットは **final-v7 / v3-semantic / metal_kernel** を現行として扱う。
+
+---
+
+# 第 II 部 — 設計提案が要求する追加仕様（**未実装**）
+
+> ここからは直近の設計分析が提案する内容。**現行コードには存在しない**。各節の冒頭に「コード上の実状」を明記する。
+
+## 6.1 アーキが要求する 3 つの新章
+
+**コード上の実状: いずれも「意味論」としては未実装。** v3 は構造コミットのみで、下記の整数意味論・丸め点・LUT は無い。
+
+1. **MoE ルーティング整数意味論** — 整数 logits 上の top-8（同点は低 index 優先）+ shared 常時、固定小数点正規化重み、**dropless 必須**（capacity 制約は batch 依存 = batch-invariance 崩壊源）。整数累積の順序不変性により grouped GEMM のスケジュール自由は数値的に無害、routing は per-token 純関数で構造的に batch-invariant。→ *現行は top_k=8 を整数パラメータとして記録するのみ。実 argmax/dispatch の整数意味論は未定義。*
+2. **Gated DeltaNet の per-token 意味論（最難関）** — `S_t=(1−β)S_{t−1}+β·v·kᵀ` の再帰 + conv1d(k=4)。**状態更新をトークン単位で再量子化（スケール・RNE 丸めを固定）**し、チャンク並列カーネルは *その per-token 丸め列を正確に再現するスケジュール*として実装（積和は順序自由、丸め点のみ固定）。**これが §6.3 teacher-forcing の成立条件**。→ *現行は delta ステップを要素数のみの `Generic` op として記録。再量子化・丸め点の定義は無い。*
+3. **適用範囲の切り出し** — mint-grade は **text-only**（画像前処理のクロスプラットフォーム決定論は別枠）。MTP 自己投機は受理規則を正準サンプラ完全一致にすれば非投機とビット同値 →「出力不変の実装自由」として合法化可能。アーティファクトは QW36-int = W4A8（int4 重み / int8 活性 / int32 累積）で ~19GB。→ *現行 runtime は既に text-only・greedy・単一実行だが、「MTP 合法化条項」や W4A8 int アーティファクト規格は未策定（現行は Q4_K_M GGUF）。*
+
+## 6.2 A 側 — レシート発行税 <1%（粗粒度コミット）
+
+**コード上の実状: 未実装。** 現行は per-op sketch（GEMM 出力 sketch）を持つが、下記の **checkpoint 連鎖**は存在しない（grep 一致なし。コード上の "checkpoint" は SQLite WAL のみ）。
+
+- 提案: per-op 全量ハッシュを廃止し、leaf root = `H(job/ctx ‖ challenge_epoch ‖ model_hash ‖ 出力トークン列ハッシュ ‖ checkpoint 連鎖 root)`。
+- checkpoint は N=64 トークン毎に `H(DeltaNet 全状態 ‖ 注意 KV 増分 ‖ routing 指紋 ‖ サンプラ RNG 状態)`。DeltaNet 状態は文脈長非依存の固定サイズ（≈16MB int8 オーダー）で checkpoint に好適。概算オーバーヘッド 0.3–0.5%。
+- → *現行 leaf は `output_commitment ‖ gemm_trace_root ‖ operation_schedule_commitment` 系の暗号コミットで、checkpoint 連鎖 root も challenge_epoch 束縛も持たない。`checkpoint interval N` はコードに無い。*
+
+## 6.3 B 側 — 検証を teacher-forced prefill にする
+
+**コード上の実状: 完全に未実装（ABSENT）。現行検証はモデルを再実行しない（§3.2）。** teacher/forced-prefill の grep 一致は無い。
+
+- 提案プロトコル: A commit → beacon → B 割当 → **A が (context + 主張トークン列) を B に開示** → B が全列を**一括 prefill** し、各位置で「seeded sampler 出力 = 主張トークン」を検査 + checkpoint digest を再現 → receipt = `Sig_B(root_B ‖ C_A)`。
+- 効果: (i) B の仕事が逐次 decode（帯域律速・低 MFU）から並列 prefill（演算律速・高 MFU）へ → 壁時計/電力 **r≈5–10x**、(ii) 縮退時の適応 m 増コストが 1/r、(iii) 分岐位置が副産物で判明し紛争が 1 セグメント（≤64 tok）に局所化。
+- **前提**: §6.1(2) — A の逐次と B の並列が **整数一致**することが仕様保証されていること。
+- → *現行の唯一の「再実行」は k=2 独立再生成のバイト一致（`audit.rs`/`matcher.rs`）。teacher-forced prefill でも checkpoint-chain replay でもない。*
+
+## 6.4 経済パラメータの再較正
+
+**コード上の実状: 未実装。`c_A` / `c_B` / `reroll` / `checkpoint interval N` はリポジトリに一切存在しない。** escrow/settlement/protocol_fee(u64) 型は `external_authority.rs` 等にあるが、self_local レシートでは `external_escrow_reference=None`。
+
+- 提案: `c_B≈c_A/r` になるため escrow を **c_A 係留（E=m·c_A）**に固定し、放棄時は m·c_B を honest B へ、差分を焼却。これで reroll 壁 `β^m > m/(m+1)` を維持（m=1:50%, m=2:82%, m=3:91%）。ペア総コストは `(1+m/r)·c_A` に低下。
+- → *現行にはこの経済モデルの実体が無い（型の骨組みのみ、非活性）。*
+
+## 6.5 移行の凍結単位（提案）
+
+- set commit を **QW9 → QW36-int（W4A8）** へ差し替え。
+- 追加章: MoE 整数意味論 / DeltaNet per-token 意味論 / LUT 群（gate・exp・sigmoid・SiLU）/ conv1d / 248K 語彙上の正準サンプラ。
+- shape bucket は genesis で文脈 cap（例 32K。native 262K は bucket 拡張、YaRN 1M は正準外）。text-only mint、MTP 合法化条項、escrow c_A 係留、checkpoint 間隔 N。
+- consensus への実デルタは **leaf root のフィールド定義変更のみ**（検査はハッシュ照合のままなので inert に land）。
+
+## 7. 現行 → 提案 ギャップ表
+
+| 提案要素（第 II 部） | 現行コード状態 | 位置づけ |
+|---|---|---|
+| MoE 整数 top-k 意味論 | 構造記録のみ（top_k=8 パラメータ+要素数） | 未実装 |
+| DeltaNet per-token 再量子化 + 丸め点固定 | `Generic` 要素数 op のみ | 未実装（§6.3 の前提） |
+| LUT 群（gate/exp/sigmoid/SiLU/conv1d） | 無し（SiLU/SsmConv は未使用 variant） | 未実装 |
+| A 側 checkpoint 連鎖 root | 無し（WAL checkpoint のみ） | 未実装 |
+| challenge_epoch を leaf に束縛 | 無し | 未実装（network gate 群と連動） |
+| B 側 teacher-forced prefill 検証 | 検証はモデル非実行 | 未実装 |
+| escrow c_A 係留 / c_A / c_B / reroll / N | 無し（escrow 型は非活性） | 未実装 |
+| W4A8 int アーティファクト（QW36-int） | Q4_K_M GGUF | 未実装 |
+| MTP 投機の合法化条項 | greedy 単一実行のみ | 未実装 |
+| compute.expert_route_trace / semantic_schedule_match ゲート消費 | レシートは値を運ぶがゲート未消費 | **in-repo で閉じ可**（提案外・§4） |
+
+---
+
+### 付記
+- 本スナップショットの現行値はすべて final-v7 レシートまたはソース `file:line` に基づく。
+- `requirements.md` は final-v6 を canonical と記載したままで drift しており、現行は本書の final-v7 / v3-semantic / metal_kernel が正。
+- 第 II 部は「これから実装すべき設計」であり、達成済みとして扱ってはならない。
diff --git a/patches/llama.cpp-palw-full.patch b/patches/llama.cpp-palw-full.patch
index 30a8646e26b92ae9aa16625760248c1dec932a98..0b08c4a30cc9f88eda3cce2751a49161823faaa9 100644
--- a/patches/llama.cpp-palw-full.patch
+++ b/patches/llama.cpp-palw-full.patch
@@ -19,7 +19,7 @@ index d3953eee..3a991741 100644
 @@ -129,6 +129,21 @@ if (CUDAToolkit_FOUND)
                               ${GGML_SOURCES_CUDA}
                              )
- 
+
 +    if (GGML_CUDA_PALW_TRACE)
 +        if (NOT IS_DIRECTORY "${PALW_CUDA_RUNTIME_DIR}" OR
 +                NOT EXISTS "${PALW_CUDA_RUNTIME_DIR}/palw_cuda_llama_mmvq.h" OR
@@ -36,7 +36,7 @@ index d3953eee..3a991741 100644
 +    endif()
 +
      add_compile_definitions(GGML_CUDA_PEER_MAX_BATCH_SIZE=${GGML_CUDA_PEER_MAX_BATCH_SIZE})
- 
+
      if (GGML_CUDA_GRAPHS)
 diff --git a/ggml/src/ggml-cuda/common.cuh b/ggml/src/ggml-cuda/common.cuh
 index 290dc4af..e2733885 100644
@@ -45,18 +45,18 @@ index 290dc4af..e2733885 100644
 @@ -40,6 +40,10 @@
  #include "vendors/cuda.h"
  #endif // defined(GGML_USE_HIP)
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +#include "palw_cuda_llama_mmvq.h"
 +#endif
 +
  #define STRINGIZE_IMPL(...) #__VA_ARGS__
  #define STRINGIZE(...) STRINGIZE_IMPL(__VA_ARGS__)
- 
+
 @@ -1388,6 +1392,48 @@ struct ggml_cuda_stream_context {
      }
  };
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +struct ggml_cuda_palw_trace_state {
 +    const palw_cuda_llama_mmvq_request_v1 * request = nullptr;
@@ -103,9 +103,9 @@ index 290dc4af..e2733885 100644
      int device;
      std::string name;
 @@ -1398,6 +1444,10 @@ struct ggml_backend_cuda_context {
- 
+
      int curr_stream_no = 0;
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    ggml_cuda_palw_trace_state palw_trace;
 +#endif
@@ -116,7 +116,7 @@ index 290dc4af..e2733885 100644
 @@ -1501,6 +1551,264 @@ struct ggml_backend_cuda_context {
      }
  };
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +static inline bool ggml_cuda_palw_trace_active(const ggml_backend_cuda_context * ctx) {
 +    return ctx != nullptr && ctx->palw_trace.active();
@@ -390,7 +390,7 @@ index 0878ab9c..c7bf90d9 100644
 @@ -3038,6 +3038,12 @@ static bool ggml_cuda_can_fuse(const struct ggml_cgraph *                cgraph,
  // try and fuse nodes and return the number of nodes to skip
  static int ggml_cuda_try_fuse(ggml_backend_cuda_context * cuda_ctx, ggml_cgraph * cgraph, int i) {
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (ggml_cuda_palw_trace_active(cuda_ctx)) {
 +        return 0;
@@ -403,7 +403,7 @@ index 0878ab9c..c7bf90d9 100644
 @@ -3926,6 +3932,12 @@ static void ggml_cuda_graph_evaluate_and_capture(ggml_backend_cuda_context * cud
                  }
                  GGML_ASSERT(ok);
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +                if (ggml_cuda_palw_trace_failed(cuda_ctx)) {
 +                    return;
@@ -415,7 +415,7 @@ index 0878ab9c..c7bf90d9 100644
                 }
 @@ -3933,7 +3945,10 @@ static void ggml_cuda_graph_evaluate_and_capture(ggml_backend_cuda_context * cud
          }
- 
+
  #ifdef USE_CUDA_GRAPH
 -        ggml_cuda_graph * graph = cuda_ctx->cuda_graph(graph_key);
 +        // A request-local PALW trace always executes directly.  In that mode
@@ -426,9 +426,9 @@ index 0878ab9c..c7bf90d9 100644
              if (graph->graph != nullptr) {
                  CUDA_CHECK(cudaGraphDestroy(graph->graph));
 @@ -3991,39 +4006,56 @@ static enum ggml_status ggml_backend_cuda_graph_compute(ggml_backend_t backend,
- 
+
      ggml_cuda_set_device(cuda_ctx->device);
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    const bool palw_trace_active = ggml_cuda_palw_trace_active(cuda_ctx);
 +    if (palw_trace_active &&
@@ -447,15 +447,15 @@ index 0878ab9c..c7bf90d9 100644
      bool use_cuda_graph             = false;
      bool cuda_graph_update_required = false;
      const void * graph_key = nullptr;
- 
+
  #ifdef USE_CUDA_GRAPH
 -    graph_key = ggml_cuda_graph_get_key(cgraph);
 +    if (!palw_trace_active) {
 +        graph_key = ggml_cuda_graph_get_key(cgraph);
- 
+
 -    ggml_cuda_graph_set_enabled(cuda_ctx, graph_key);
 +        ggml_cuda_graph_set_enabled(cuda_ctx, graph_key);
- 
+
 -    ggml_cuda_graph * graph = cuda_ctx->cuda_graph(graph_key);
 -    if (graph->is_enabled()) {
 -        const bool graph_compatible = ggml_cuda_graph_check_compability(cgraph);
@@ -508,9 +508,9 @@ index 0878ab9c..c7bf90d9 100644
              }
          }
 @@ -4042,6 +4074,12 @@ static enum ggml_status ggml_backend_cuda_graph_compute(ggml_backend_t backend,
- 
+
      ggml_cuda_graph_evaluate_and_capture(cuda_ctx, cgraph, use_cuda_graph, cuda_graph_update_required, graph_key);
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (ggml_cuda_palw_trace_failed(cuda_ctx)) {
 +        return GGML_STATUS_FAILED;
@@ -519,11 +519,11 @@ index 0878ab9c..c7bf90d9 100644
 +
      return GGML_STATUS_SUCCESS;
  }
- 
+
 @@ -4073,6 +4111,19 @@ static void ggml_backend_cuda_event_wait(ggml_backend_t backend, ggml_backend_ev
  static void ggml_backend_cuda_graph_optimize(ggml_backend_t backend, ggml_cgraph * cgraph) {
      ggml_backend_cuda_context * cuda_ctx = (ggml_backend_cuda_context *) backend->context;
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (ggml_cuda_palw_trace_active(cuda_ctx)) {
 +        if (cuda_ctx->curr_stream_no != 0 ||
@@ -543,7 +543,7 @@ index 0878ab9c..c7bf90d9 100644
 @@ -5137,6 +5188,498 @@ static ggml_backend_feature * ggml_backend_cuda_get_features(ggml_backend_reg_t
      GGML_UNUSED(reg);
  }
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +static void ggml_backend_cuda_palw_report_unbound_fault(
 +        const palw_cuda_llama_mmvq_request_v1 * request,
@@ -1083,15 +1083,15 @@ index 0878ab9c..c7bf90d9 100644
 +#endif
      return nullptr;
  }
- 
+
 diff --git a/ggml/src/ggml-cuda/mmvf.cu b/ggml/src/ggml-cuda/mmvf.cu
 index d7dbc8b9..13e3323a 100644
 --- a/ggml/src/ggml-cuda/mmvf.cu
 +++ b/ggml/src/ggml-cuda/mmvf.cu
 @@ -409,6 +409,64 @@ static void mul_mat_vec_f_switch_fusion(
- 
+
  }
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +template<typename type_acc, int block_size>
 +static void ggml_cuda_palw_launch_attention_mmvf(
@@ -1154,9 +1154,9 @@ index d7dbc8b9..13e3323a 100644
  void launch_mul_mat_vec_f_cuda(
          const T * x, const float * y, const int32_t * ids, const ggml_cuda_mm_fusion_args_device fusion, float * dst,
 @@ -698,6 +756,55 @@ void ggml_cuda_mul_mat_vec_f(ggml_backend_cuda_context & ctx, const ggml_tensor
- 
+
      const int64_t ids_stride = ids ? ids->nb[1] / ggml_type_size(ids->type) : 0;
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (ggml_cuda_palw_trace_v2_attention_active(&ctx)) {
 +        const auto & association = ctx.palw_trace.association_v2;
@@ -1212,7 +1212,7 @@ index d7dbc8b9..13e3323a 100644
 @@ -722,6 +829,70 @@ void ggml_cuda_mul_mat_vec_f(ggml_backend_cuda_context & ctx, const ggml_tensor
      }
  }
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +palw_cuda_trace_status ggml_cuda_palw_mmvf_attention_kernel_info_v1(
 +        int device,
@@ -1286,7 +1286,7 @@ index a50f7c02..3baabfdf 100644
 +++ b/ggml/src/ggml-cuda/mmvf.cuh
 @@ -12,3 +12,10 @@ void ggml_cuda_op_mul_mat_vec_f(
      const int64_t src1_padded_row_size, cudaStream_t stream);
- 
+
  bool ggml_cuda_should_use_mmvf(enum ggml_type type, int cc, const int64_t * src0_ne, const size_t * src0_nb, int64_t ne11);
 +
 +#if defined(GGML_CUDA_PALW_TRACE)
@@ -1302,18 +1302,18 @@ index e18ada53..c84b5420 100644
 @@ -3,6 +3,10 @@
  #include "unary.cuh"
  #include "vecdotq.cuh"
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +#include "palw_cuda_producer_trace.cuh"
 +#endif
 +
  #include <cstdint>
- 
+
  typedef float (*vec_dot_q_cuda_t)(const void * __restrict__ vbq, const block_q8_1 * __restrict__ bq8_1, const int & kbx, const int & iqs);
 @@ -475,6 +479,75 @@ static constexpr __host__ __device__ int calc_rows_per_block(int ncols_dst, int
      return 1;
  }
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +static_assert(PALW_CUDA_PRODUCER_MMVQ_KERNEL_ARGUMENT_COUNT_V3 == 20U);
 +static_assert(PALW_CUDA_PRODUCER_MMVQ_VIEW_ARGUMENT_INDEX_V3 == 19U);
@@ -1401,7 +1401,7 @@ index e18ada53..c84b5420 100644
      const int32_t * GGML_CUDA_RESTRICT ids = ids_ptr;
 @@ -657,6 +734,18 @@ static __global__ void mul_mat_vec_q(
              }
- 
+
              if (threadIdx.x == i && (rows_per_cuda_block == 1 || uint32_t(row0 + i) < stride_col_dst)) {
 +#if defined(GGML_CUDA_PALW_TRACE)
 +                if (palw_trace_view.abi_version != 0U) {
@@ -1421,7 +1421,7 @@ index e18ada53..c84b5420 100644
 @@ -698,6 +787,66 @@ static __global__ void mul_mat_vec_q(
      }
  }
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +template <ggml_type type>
 +static palw_cuda_trace_status palw_mmvq_kernel_info_for_type_v1(
@@ -1495,7 +1495,7 @@ index e18ada53..c84b5420 100644
 +        , ggml_backend_cuda_context * palw_ctx, const void * palw_operation_token
 +#endif
 +        ) {
- 
+
      const bool has_fusion = fusion.gate != nullptr || fusion.x_bias != nullptr || fusion.gate_bias != nullptr ||
                              fusion.x_scale != nullptr || fusion.gate_scale != nullptr;
 +
@@ -1639,7 +1639,7 @@ index e18ada53..c84b5420 100644
 +#endif
 +        );
  }
- 
+
  template <ggml_type type>
 @@ -842,7 +1118,12 @@ static void mul_mat_vec_q_switch_ncols_dst(
          const int nchannels_x, const int nchannels_y, const int nchannels_dst,
@@ -1652,13 +1652,13 @@ index e18ada53..c84b5420 100644
 +        const void * palw_operation_token = nullptr
 +#endif
 +        ) {
- 
+
      GGML_ASSERT(ncols_x % ggml_blck_size(type) == 0);
      GGML_ASSERT(ncols_dst <= MMVQ_MAX_BATCH_SIZE);
 @@ -858,6 +1139,26 @@ static void mul_mat_vec_q_switch_ncols_dst(
- 
+
      const bool has_ids = ids != nullptr;
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (ggml_cuda_palw_trace_active(palw_ctx)) {
 +        if (ggml_cuda_palw_trace_failed(palw_ctx)) {
@@ -1856,7 +1856,7 @@ index e18ada53..c84b5420 100644
 @@ -1149,6 +1513,28 @@ void ggml_cuda_mul_mat_vec_q(
      GGML_ASSERT(        dst->type  == GGML_TYPE_F32);
      GGML_ASSERT(!ids || ids->type  == GGML_TYPE_I32); // Optional, used for batched GGML_MUL_MAT_ID.
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (ggml_cuda_palw_trace_active(&ctx) && ctx.palw_trace.request_v2 != nullptr) {
 +        if (ggml_cuda_palw_trace_failed(&ctx)) {
@@ -1880,7 +1880,7 @@ index e18ada53..c84b5420 100644
 +#endif
 +
      GGML_TENSOR_BINARY_OP_LOCALS;
- 
+
      cudaStream_t stream = ctx.stream();
 @@ -1254,7 +1640,11 @@ void ggml_cuda_mul_mat_vec_q(
          src0->data, src0->type, src1_q8_1.get(), ids_d, fusion_local, dst_d, ne00,
@@ -1893,7 +1893,7 @@ index e18ada53..c84b5420 100644
 +#endif
 +        );
  }
- 
+
  void ggml_cuda_op_mul_mat_vec_q(
 @@ -1283,7 +1673,11 @@ void ggml_cuda_op_mul_mat_vec_q(
      ggml_cuda_mm_fusion_args_device fusion_local{};
@@ -1905,7 +1905,7 @@ index e18ada53..c84b5420 100644
 +        , &ctx, dst
 +#endif
 +        );
- 
+
      GGML_UNUSED_VARS(src1, dst, src1_ddf_i, src1_ncols, src1_padded_row_size);
  }
 diff --git a/ggml/src/ggml-cuda/mmvq.cuh b/ggml/src/ggml-cuda/mmvq.cuh
@@ -1932,7 +1932,7 @@ index 285c0e95..1b9ad656 100644
 @@ -436,6 +436,62 @@ void ggml_cuda_op_soft_max(ggml_backend_cuda_context & ctx, ggml_tensor * dst) {
      params.m0 = m0;
      params.m1 = m1;
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (ggml_cuda_palw_trace_v2_attention_active(&ctx)) {
 +        const bool preflight = ggml_cuda_palw_trace_attention_preflight(
@@ -1995,7 +1995,7 @@ index 285c0e95..1b9ad656 100644
 @@ -443,6 +499,65 @@ void ggml_cuda_op_soft_max(ggml_backend_cuda_context & ctx, ggml_tensor * dst) {
      }
  }
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +palw_cuda_trace_status ggml_cuda_palw_softmax_attention_kernel_info_v1(
 +        int device,
@@ -2064,7 +2064,7 @@ index 93dfee83..997a0ffb 100644
 +++ b/ggml/src/ggml-cuda/softmax.cuh
 @@ -5,3 +5,10 @@
  void ggml_cuda_op_soft_max(ggml_backend_cuda_context & ctx, ggml_tensor * dst);
- 
+
  void ggml_cuda_op_soft_max_back(ggml_backend_cuda_context & ctx, ggml_tensor * dst);
 +
 +#if defined(GGML_CUDA_PALW_TRACE)
@@ -2080,7 +2080,7 @@ index a311ac20..a7a36ec2 100644
 @@ -7,6 +7,10 @@
  #include "ggml-opt.h"
  #include "gguf.h"
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +#include "palw_cuda_llama_mmvq.h"
 +#endif
@@ -2094,12 +2094,12 @@ index a311ac20..a7a36ec2 100644
          struct llama_context * ctx_other;
 +
      };
- 
+
      struct llama_model_tensor_override {
 @@ -527,6 +532,70 @@ extern "C" {
      // Frees all allocated memory
      LLAMA_API void llama_free(struct llama_context * ctx);
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    // Creates the V3 producer on this context's exact CUDA backend and binds a
 +    // request before its first decode. request->producer_context must be NULL.
@@ -2165,16 +2165,16 @@ index a311ac20..a7a36ec2 100644
 +#endif
 +
      LLAMA_API int64_t llama_time_us(void);
- 
+
      LLAMA_API size_t llama_max_devices(void);
 diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
 index 320784c3..42a11f9c 100644
 --- a/src/CMakeLists.txt
 +++ b/src/CMakeLists.txt
 @@ -55,6 +55,13 @@ target_compile_features   (llama PRIVATE cxx_std_17) # don't bump
- 
+
  target_link_libraries(llama PUBLIC ggml)
- 
+
 +if (GGML_CUDA_PALW_TRACE)
 +    target_compile_definitions(llama PUBLIC
 +        GGML_CUDA_PALW_TRACE=1
@@ -2192,7 +2192,7 @@ index 3a469bc9..4e2df4b8 100644
 @@ -19,6 +19,14 @@
  #include <stdexcept>
  #include <string>
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +static_assert(PALW_CUDA_TRACE_PRODUCTION_CAPABLE == 0U, "PALW CUDA trace must remain non-production");
 +static_assert(PALW_CUDA_PRODUCER_PRODUCTION_CAPABLE == 0U, "PALW CUDA producer must remain non-production");
@@ -2207,13 +2207,13 @@ index 3a469bc9..4e2df4b8 100644
 @@ -119,6 +127,10 @@ llama_context::llama_context(
      cparams.cb_eval           = params.cb_eval;
      cparams.cb_eval_user_data = params.cb_eval_user_data;
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    cparams.palw_cuda_trace_request = nullptr;
 +#endif
 +
      cparams.ctx_other = nullptr;
- 
+
      // TODO: more generic
 @@ -448,9 +460,34 @@ llama_context::llama_context(
              sampling.token_ids_full_vocab[i] = i;
@@ -2221,7 +2221,7 @@ index 3a469bc9..4e2df4b8 100644
      }
 +
  }
- 
+
  llama_context::~llama_context() {
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (palw_cuda_trace_bound) {
@@ -2253,7 +2253,7 @@ index 3a469bc9..4e2df4b8 100644
 @@ -470,6 +507,786 @@ llama_context::~llama_context() {
      ggml_opt_free(opt_ctx);
  }
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +void llama_context::palw_cuda_trace_record_status(palw_cuda_trace_status status) {
 +    if (palw_cuda_trace_status_ == PALW_CUDA_TRACE_OK && status != PALW_CUDA_TRACE_OK) {
@@ -3039,7 +3039,7 @@ index 3a469bc9..4e2df4b8 100644
      auto resolve = [&](const llm_fused_op_probe & probe, bool & enabled) {
 @@ -1312,7 +2129,19 @@ llm_graph_result * llama_context::process_ubatch(const llama_ubatch & ubatch, ll
          res->reset();
- 
+
          ggml_backend_sched_reset(sched.get());
 +#if defined(GGML_CUDA_PALW_TRACE)
 +        if (palw_cuda_trace_mixed_stream) {
@@ -3054,12 +3054,12 @@ index 3a469bc9..4e2df4b8 100644
 +#else
          ggml_backend_sched_set_eval_callback(sched.get(), cparams.cb_eval, cparams.cb_eval_user_data);
 +#endif
- 
+
          //const auto t_start_us = ggml_time_us();
- 
+
 @@ -2424,6 +3253,12 @@ ggml_status llama_context::graph_compute(
      }
- 
+
      auto status = ggml_backend_sched_graph_compute_async(sched.get(), gf);
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (status == GGML_STATUS_SUCCESS && palw_cuda_trace_bound &&
@@ -3071,7 +3071,7 @@ index 3a469bc9..4e2df4b8 100644
          LLAMA_LOG_ERROR("%s: ggml_backend_sched_graph_compute_async failed with error %d\n", __func__, status);
      }
 @@ -2435,6 +3270,49 @@ ggml_status llama_context::graph_compute(
- 
+
  llm_graph_cb llama_context::graph_get_cb() const {
      return [&](const llama_ubatch & ubatch, ggml_tensor * cur, const char * name, int il) {
 +#if defined(GGML_CUDA_PALW_TRACE)
@@ -3123,7 +3123,7 @@ index 3a469bc9..4e2df4b8 100644
 @@ -3114,6 +3992,15 @@ size_t llama_context::state_write_data(llama_io_write_i & io) {
  size_t llama_context::state_read_data(llama_io_read_i & io) {
      LLAMA_LOG_DEBUG("%s: reading state\n", __func__);
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (palw_cuda_trace_bound || palw_cuda_trace_producer_owned) {
 +        throw std::runtime_error("cannot import context state while a PALW CUDA trace exists");
@@ -3139,7 +3139,7 @@ index 3a469bc9..4e2df4b8 100644
 @@ -3150,6 +4037,13 @@ size_t llama_context::state_seq_write_data(llama_io_write_i & io, llama_seq_id s
  size_t llama_context::state_seq_read_data(llama_io_read_i & io, llama_seq_id seq_id, llama_state_seq_flags flags) {
      GGML_UNUSED(seq_id);
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    if (palw_cuda_trace_bound || palw_cuda_trace_producer_owned) {
 +        throw std::runtime_error("cannot import sequence state while a PALW CUDA trace exists");
@@ -3153,7 +3153,7 @@ index 3a469bc9..4e2df4b8 100644
 @@ -3568,6 +4462,96 @@ void llama_free(llama_context * ctx) {
      delete ctx;
  }
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +palw_cuda_trace_status llama_palw_cuda_trace_attach(
 +        llama_context * ctx,
@@ -3253,16 +3253,16 @@ index bf91daa8..a9753b00 100644
 +++ b/src/llama-context.h
 @@ -12,6 +12,7 @@
  #include "ggml-opt.h"
- 
+
  #include <map>
 +#include <unordered_map>
  #include <vector>
- 
+
  struct llama_model;
 @@ -247,6 +248,33 @@ public:
      // returns the result of ggml_backend_sched_graph_compute_async execution
      ggml_status graph_compute(ggml_cgraph * gf, bool batched);
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    palw_cuda_trace_status palw_cuda_trace_attach(
 +        uint64_t record_capacity,
@@ -3294,9 +3294,9 @@ index bf91daa8..a9753b00 100644
      ggml_cgraph * graph_reserve(
          uint32_t n_tokens, uint32_t n_seqs, uint32_t n_outputs, const llama_memory_context_i * mctx, bool split_only = false, size_t * sizes = nullptr);
 @@ -262,6 +290,18 @@ private:
- 
+
      llm_graph_cb graph_get_cb() const;
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    void palw_cuda_trace_bind();
 +    bool palw_cuda_trace_eval(ggml_tensor * tensor, bool ask);
@@ -3315,7 +3315,7 @@ index bf91daa8..a9753b00 100644
 @@ -348,6 +388,49 @@ private:
      ggml_backend_t backend_cpu = nullptr;
      std::vector<ggml_backend_ptr> backends;
- 
+
 +#if defined(GGML_CUDA_PALW_TRACE)
 +    ggml_backend_t palw_cuda_trace_backend = nullptr;
 +    const palw_cuda_llama_mmvq_backend_api_v1 * palw_cuda_trace_backend_api = nullptr;
@@ -3361,14 +3361,14 @@ index bf91daa8..a9753b00 100644
 +
      // training
      ggml_opt_context_t opt_ctx = nullptr;
- 
+
 diff --git a/src/llama-cparams.h b/src/llama-cparams.h
 index 58520caa..7140b114 100644
 --- a/src/llama-cparams.h
 +++ b/src/llama-cparams.h
 @@ -58,4 +58,8 @@ struct llama_cparams {
      void * cb_eval_user_data;
- 
+
      llama_context * ctx_other;
 +
 +#if defined(GGML_CUDA_PALW_TRACE)
@@ -6722,3 +6722,227 @@ index 00000000..5e2646b1
 +    }
 +    return 0;
 +}
+diff --git a/src/models/qwen35moe.cpp b/src/models/qwen35moe.cpp
+index 7b0876cb..4d955261 100644
+--- a/src/models/qwen35moe.cpp
++++ b/src/models/qwen35moe.cpp
+@@ -6,7 +6,18 @@ void llama_model_qwen35moe::load_arch_hparams(llama_model_loader & ml) {
+     ml.get_key(LLM_KV_EXPERT_SHARED_FEED_FORWARD_LENGTH, hparams.n_ff_shexp, false);
+     ml.get_key(LLM_KV_ATTENTION_LAYERNORM_RMS_EPS,       hparams.f_norm_rms_eps);
+
+-    ml.get_key_or_arr(LLM_KV_ROPE_DIMENSION_SECTIONS,    hparams.rope_sections, 4, true);
++    // PALW: newer HF->GGUF conversions write 3 mrope sections ([t, h, w]) and
++    // omit the trailing zero; older conversions write 4. Accept both forms and
++    // zero-pad so the pinned runtime loads current upstream GGUF artifacts.
++    {
++        std::vector<int32_t> sections;
++        ml.get_arr(LLM_KV_ROPE_DIMENSION_SECTIONS, sections, true);
++        if (sections.size() != 3 && sections.size() != 4) {
++            throw std::runtime_error("rope.dimension_sections must have 3 or 4 entries");
++        }
++        std::fill(hparams.rope_sections.begin(), hparams.rope_sections.end(), 0);
++        std::copy(sections.begin(), sections.end(), hparams.rope_sections.begin());
++    }
+
+     // Load linear attention (gated delta net) parameters
+     ml.get_key(LLM_KV_SSM_CONV_KERNEL,    hparams.ssm_d_conv);
+@@ -73,8 +84,13 @@ void llama_model_qwen35moe::load_arch_tensors(llama_model_loader & ml) {
+         layer.attn_post_norm = create_tensor(tn(LLM_TENSOR_ATTN_POST_NORM, "weight", il), { n_embd }, flags);
+
+         if (!hparams.is_recr(il)) {
+-            // Attention layers
+-            create_tensor_qkv(layer, il, n_embd, n_embd_head_k * n_head * 2, n_embd_k_gqa, n_embd_v_gqa, flags);
++            // Attention layers. The LLAMA_LOAD_LOCALS macro derives the global
++            // n_embd_k_gqa/n_embd_v_gqa from layer 0, which in this MoE is a
++            // linear-attention (recurrent) layer with n_head_kv == 0. Use the
++            // uniform full-attention KV projection width instead.
++            const int64_t n_embd_k_gqa_attn = hparams.n_embd_k_gqa_max();
++            const int64_t n_embd_v_gqa_attn = hparams.n_embd_v_gqa_max();
++            create_tensor_qkv(layer, il, n_embd, n_embd_head_k * n_head * 2, n_embd_k_gqa_attn, n_embd_v_gqa_attn, flags);
+             layer.wo = create_tensor(tn(LLM_TENSOR_ATTN_OUT, "weight", il), { n_embd_head_k * n_head, n_embd }, flags);
+
+             // Q/K normalization for attention layers
+@@ -86,7 +102,12 @@ void llama_model_qwen35moe::load_arch_tensors(llama_model_loader & ml) {
+             layer.wqkv           = create_tensor(tn(LLM_TENSOR_ATTN_QKV,       "weight", il), { n_embd, key_dim * 2 + value_dim }, TENSOR_NOT_REQUIRED);
+             layer.wqkv_gate      = create_tensor(tn(LLM_TENSOR_ATTN_GATE,      "weight", il), { n_embd, value_dim }, TENSOR_NOT_REQUIRED);
+             layer.ssm_conv1d     = create_tensor(tn(LLM_TENSOR_SSM_CONV1D,     "weight", il), { hparams.ssm_d_conv, conv_dim }, flags);
+-            layer.ssm_dt         = create_tensor(tn(LLM_TENSOR_SSM_DT,         "bias",   il), { hparams.ssm_dt_rank }, flags);
++            // PALW: some conversions store the delta-time bias without the
++            // ".bias" suffix ("blk.N.ssm_dt"). Accept both spellings.
++            layer.ssm_dt         = create_tensor(tn(LLM_TENSOR_SSM_DT,         "bias",   il), { hparams.ssm_dt_rank }, flags | TENSOR_NOT_REQUIRED);
++            if (!layer.ssm_dt) {
++                layer.ssm_dt     = create_tensor(tn(LLM_TENSOR_SSM_DT,                   il), { hparams.ssm_dt_rank }, flags);
++            }
+             layer.ssm_a          = create_tensor(tn(LLM_TENSOR_SSM_A_NOSCAN,             il), { hparams.ssm_dt_rank }, flags);
+             layer.ssm_beta       = create_tensor(tn(LLM_TENSOR_SSM_BETA,       "weight", il), { n_embd, n_v_heads }, flags);
+             layer.ssm_alpha      = create_tensor(tn(LLM_TENSOR_SSM_ALPHA,      "weight", il), { n_embd, n_v_heads }, flags);
+@@ -116,7 +137,11 @@ void llama_model_qwen35moe::load_arch_tensors(llama_model_loader & ml) {
+         layer.attn_norm      = create_tensor(tn(LLM_TENSOR_ATTN_NORM,      "weight", il), { n_embd }, 0);
+         layer.attn_post_norm = create_tensor(tn(LLM_TENSOR_ATTN_POST_NORM, "weight", il), { n_embd }, 0);
+
+-        create_tensor_qkv(layer, il, n_embd, n_embd_head_k * n_head * 2, n_embd_k_gqa, n_embd_v_gqa, 0);
++        // The MTP layer index has no entry in the per-layer n_head_kv array, so
++        // derive the KV projection width from the full-attention trunk layers.
++        const int64_t n_embd_k_gqa_mtp = hparams.n_embd_k_gqa_max();
++        const int64_t n_embd_v_gqa_mtp = hparams.n_embd_v_gqa_max();
++        create_tensor_qkv(layer, il, n_embd, n_embd_head_k * n_head * 2, n_embd_k_gqa_mtp, n_embd_v_gqa_mtp, 0);
+         layer.wo          = create_tensor(tn(LLM_TENSOR_ATTN_OUT,    "weight", il), { n_embd_head_k * n_head, n_embd }, 0);
+         layer.attn_q_norm = create_tensor(tn(LLM_TENSOR_ATTN_Q_NORM, "weight", il), { n_embd_head_k }, 0);
+         layer.attn_k_norm = create_tensor(tn(LLM_TENSOR_ATTN_K_NORM, "weight", il), { n_embd_head_k }, 0);
+@@ -147,6 +172,24 @@ void llama_model_qwen35moe::load_arch_tensors(llama_model_loader & ml) {
+     for (int i = n_layer; i < n_layer_all; ++i) {
+         load_block_mtp(i);
+     }
++
++    // PALW: the Ollama-packaged Qwen3.6-35B-A3B GGUF bundles the multimodal
++    // vision tower ("v.*") and, when the next-token/MTP head is not enabled by
++    // hyperparameters, the MTP sub-model ("mtp.*") in the same file. The pinned
++    // text runtime never builds those sibling sub-models, so account for their
++    // tensors here; otherwise done_getting_tensors() rejects the load for
++    // having created fewer tensors than the file contains. This does not weaken
++    // the check for a genuinely missing text tensor: only tensors that exist in
++    // the file under these sibling prefixes are counted, exactly once each.
++    for (const auto & entry : ml.weights_map) {
++        const std::string & name = entry.first;
++        const bool is_vision = name.rfind("v.", 0) == 0;
++        const bool is_mtp    = name.rfind("mtp.", 0) == 0;
++        if (is_vision || is_mtp) {
++            ml.size_data -= ggml_nbytes(entry.second.tensor);
++            ml.n_created++;
++        }
++    }
+ }
+
+ std::unique_ptr<llm_graph_context> llama_model_qwen35moe::build_arch_graph(const llm_graph_params & params) const {
+@@ -287,6 +330,12 @@ ggml_tensor * llama_model_qwen35moe::graph::build_layer_attn(
+     const int64_t n_embd_head = hparams.n_embd_head_v();
+     GGML_ASSERT(n_embd_head == hparams.n_embd_head_k());
+
++    // PALW: the llm_graph_context base initializes n_head/n_head_kv from layer
++    // 0, which in this hybrid MoE is a linear-attention layer with n_head_kv 0.
++    // Use the per-layer counts for the full-attention reshapes below.
++    const int64_t n_head    = hparams.n_head(il);
++    const int64_t n_head_kv = hparams.n_head_kv(il);
++
+     // Order: joint QG projection, QG split, Q norm, KV projection, K norm, RoPE, attention
+
+     // Qwen3Next uses a single Q projection that outputs query + gate
+diff --git a/ggml/include/ggml-metal.h b/ggml/include/ggml-metal.h
+index 433838f0..213e148d 100644
+--- a/ggml/include/ggml-metal.h
++++ b/ggml/include/ggml-metal.h
+@@ -56,6 +56,21 @@ GGML_BACKEND_API void ggml_backend_metal_capture_next_compute(ggml_backend_t bac
+
+ GGML_BACKEND_API ggml_backend_reg_t ggml_backend_metal_reg(void);
+
++// PALW kernel-level dispatch hook.
++//
++// When set (process-global), the callback is invoked for every Metal compute
++// dispatch with the bound pipeline (kernel) name and the launch geometry
++// (threadgroup grid tg0..2 and threads-per-threadgroup tptg0..2). This lets the
++// PALW observer produce a kernel-level execution trace bound to the actual GPU
++// kernel dispatches rather than to graph-node outputs. Pass NULL to disable.
++typedef void (*ggml_metal_palw_dispatch_cb)(
++        void * user_data,
++        const char * pipeline,
++        int tg0, int tg1, int tg2,
++        int tptg0, int tptg1, int tptg2);
++
++GGML_BACKEND_API void ggml_metal_palw_set_dispatch_hook(ggml_metal_palw_dispatch_cb cb, void * user_data);
++
+ #ifdef __cplusplus
+ }
+ #endif
+diff --git a/ggml/src/ggml-metal/ggml-metal-device.m b/ggml/src/ggml-metal/ggml-metal-device.m
+index 80e47f2c..3e36c08d 100644
+--- a/ggml/src/ggml-metal/ggml-metal-device.m
++++ b/ggml/src/ggml-metal/ggml-metal-device.m
+@@ -1,5 +1,6 @@
+ #import "ggml-metal-device.h"
+
++#import "ggml-metal.h"
+ #import "ggml-impl.h"
+ #import "ggml-backend-impl.h"
+
+@@ -72,6 +73,9 @@ void ggml_metal_cv_set_bool(ggml_metal_cv_t cv, bool value, int32_t idx) {
+
+ struct ggml_metal_pipeline {
+     id<MTLComputePipelineState> obj;
++
++    // PALW: stable kernel (pipeline) name, captured for kernel-level tracing.
++    char name[128];
+ };
+
+ ggml_metal_pipeline_t ggml_metal_pipeline_init(void) {
+@@ -79,6 +83,7 @@ ggml_metal_pipeline_t ggml_metal_pipeline_init(void) {
+
+     *res = (struct ggml_metal_pipeline) {
+         /*.obj  =*/ nil,
++        /*.name =*/ {0},
+     };
+
+     return res;
+@@ -443,6 +448,8 @@ struct ggml_metal_pipeline_with_params ggml_metal_library_compile_pipeline(ggml_
+
+         res.pipeline = ggml_metal_pipeline_init();
+         res.pipeline->obj = obj;
++        // PALW: record the stable kernel name for kernel-level dispatch tracing.
++        snprintf(res.pipeline->name, sizeof(res.pipeline->name), "%s", name);
+
+         ggml_metal_pipelines_add(lib->pipelines, name, res.pipeline);
+     }
+@@ -458,8 +465,23 @@ struct ggml_metal_pipeline_with_params ggml_metal_library_compile_pipeline(ggml_
+
+ struct ggml_metal_encoder {
+     id<MTLComputeCommandEncoder> obj;
++
++    // PALW: name of the pipeline currently bound, for kernel-level dispatch tracing.
++    const char * cur_pipeline;
+ };
+
++// PALW: process-global kernel-dispatch hook. When set, it is invoked for every
++// Metal compute dispatch with the bound pipeline (kernel) name and the launch
++// geometry (threadgroup grid + threads-per-threadgroup). Used by the PALW
++// observer to produce a kernel-level (not graph-fallback) execution trace.
++static ggml_metal_palw_dispatch_cb g_palw_dispatch_cb = NULL;
++static void *                      g_palw_dispatch_ud = NULL;
++
++void ggml_metal_palw_set_dispatch_hook(ggml_metal_palw_dispatch_cb cb, void * user_data) {
++    g_palw_dispatch_cb = cb;
++    g_palw_dispatch_ud = user_data;
++}
++
+ ggml_metal_encoder_t ggml_metal_encoder_init(ggml_metal_cmd_buf_t cmd_buf_raw, bool concurrent) {
+     ggml_metal_encoder_t res = calloc(1, sizeof(struct ggml_metal_encoder));
+
+@@ -491,6 +513,8 @@ void ggml_metal_encoder_debug_group_pop (ggml_metal_encoder_t encoder) {
+
+ void ggml_metal_encoder_set_pipeline(ggml_metal_encoder_t encoder, struct ggml_metal_pipeline_with_params pipeline) {
+     [encoder->obj setComputePipelineState:pipeline.pipeline->obj];
++    // PALW: remember the bound kernel name so dispatches can be attributed to it.
++    encoder->cur_pipeline = pipeline.pipeline->name;
+ }
+
+ void ggml_metal_encoder_set_bytes(ggml_metal_encoder_t encoder, void * data, size_t size, int idx) {
+@@ -506,6 +530,11 @@ void ggml_metal_encoder_set_threadgroup_memory_size(ggml_metal_encoder_t encoder
+ }
+
+ void ggml_metal_encoder_dispatch_threadgroups(ggml_metal_encoder_t encoder, int tg0, int tg1, int tg2, int tptg0, int tptg1, int tptg2) {
++    // PALW: report the kernel-level dispatch (bound pipeline + launch geometry).
++    if (g_palw_dispatch_cb) {
++        g_palw_dispatch_cb(g_palw_dispatch_ud, encoder->cur_pipeline ? encoder->cur_pipeline : "",
++                tg0, tg1, tg2, tptg0, tptg1, tptg2);
++    }
+     [encoder->obj dispatchThreadgroups:MTLSizeMake(tg0, tg1, tg2) threadsPerThreadgroup:MTLSizeMake(tptg0, tptg1, tptg2)];
+ }
+
+diff --git a/tools/palw-observer/PALW_PATCHSET b/tools/palw-observer/PALW_PATCHSET
+new file mode 100644
+index 00000000..887d5502
+--- /dev/null
++++ b/tools/palw-observer/PALW_PATCHSET
+@@ -0,0 +1,4 @@
++palw-full-patch-v1
++base=12127defda4f41b7679cb2477a4b0d65ee6a0c8f
++scope=cuda-trace,metal-dispatch,qwen35-gguf-compat,observer
++receipt-authority=false
diff --git a/runtime-palw/Cargo.toml b/runtime-palw/Cargo.toml
index 99a7810a581dc620085f6d908192bd8f21a38db7..3fe5e221a29f60ccf824f83994c25b2c4d007a8f 100644
--- a/runtime-palw/Cargo.toml
+++ b/runtime-palw/Cargo.toml
@@ -22,6 +22,11 @@ name = "palw-verify-integer"
 path = "src/bin/palw-verify-integer.rs"
 required-features = ["ml-dsa"]
 
+[[bin]]
+name = "palw-lifecycle"
+path = "src/bin/palw-lifecycle.rs"
+required-features = ["ml-dsa"]
+
 
 [dependencies]
 chacha20poly1305 = { version = "=0.10.1", features = ["std"] }
diff --git a/runtime-palw/docs/palw-lifecycle.md b/runtime-palw/docs/palw-lifecycle.md
new file mode 100644
index 0000000000000000000000000000000000000000..ae8b6c9831f02ebad4558d8fbd8675892fae5552
--- /dev/null
+++ b/runtime-palw/docs/palw-lifecycle.md
@@ -0,0 +1,231 @@
+# PALW Receipt-v3 lifecycle operator guide
+
+`palw-lifecycle` is a durable, fail-closed control plane for externally funded PALW work. It
+coordinates funding, escrow reservation, two-worker assignment, Receipt-v3 admission, settlement,
+timeouts/refunds, bond slashing, and unbonding. It does not move money itself and it is not node
+consensus.
+
+## Security boundary
+
+The lifecycle database contains public keys, public Receipt-v3 verification keys, signed envelopes,
+receipt bodies, payment command IDs, and external confirmation IDs. It must never contain Ed25519
+signing keys, ML-DSA signing seeds, wallet keys, payment credentials, prompt plaintext, or API
+tokens. The CLI has no option for private/signing material and does not print canonical signed blobs
+unless the operator supplied them separately.
+
+The authority registry is network scoped. `authority-add` is an explicit out-of-band trust-root
+operation, not a self-signed governance claim. Secure the database file and independently verify the
+network ID, public key, validity interval, and least-privilege permission set before bootstrap.
+
+Permissions are independent:
+
+- `funding`: finalized external escrow funding
+- `lifecycle`: escrow lock, assignment, settlement preparation, timeout preparation
+- `admission`: Receipt-v3 admission after ML-DSA verification
+- `terminal`: external settlement/refund finality confirmation
+- `bond`: finalized bond funding and externally confirmed unbond
+- `slash`: final slash decisions
+
+Keys are bound to a 64-byte network/genesis ID, an inclusive epoch interval, an optional inclusive
+revocation epoch, and their permission mask. A signature from the wrong network, epoch, key ID, or
+capability is rejected before SQLite mutation begins.
+
+## Durable state machine
+
+```text
+Funded -> Locked -> Assigned -> ReceiptOne -> EvidenceReady
+                                                 |
+                                                 v
+                                  SettlementPrepared -> Settled
+
+Funded/Locked/Assigned/ReceiptOne/EvidenceReady -- timeout --> RefundPrepared -> Refunded
+Assigned/ReceiptOne/EvidenceReady -- final slash ------------> RefundPrepared -> Refunded
+```
+
+Preparation only creates a deterministic external payment command. It does not claim that funds
+moved. `Settled` or `Refunded` requires a later, separately signed `terminal` event that binds the
+exact command ID and a non-zero external rail confirmation ID.
+
+Every mutation carries:
+
+- event schema version and target-state version;
+- typed event discriminant and strictly encoded typed payload;
+- network ID and evidence/decision epoch;
+- exact next target sequence;
+- non-zero authority nonce;
+- authority key ID and Ed25519 signature.
+
+The event ID commits to the exact complete signed envelope. Exact replay is idempotent only while
+the target remains at the recorded post-sequence and post-state. Replaying an old event after a
+later transition fails. Reusing an authority nonce for different bytes fails.
+
+Job and execution nullifiers are unique across the whole network namespace in one database:
+`(network_id, job_nullifier)` and `(network_id, execution_nullifier)`. The same raw nullifier in a
+different test/dev network does not cause cross-network denial of service.
+
+External funding/finality identities share one network-wide ledger even when their message types
+differ. An escrow funding reference cannot be reused as bond funding; settlement/refund rail
+confirmation IDs cannot be reused for unbonding; slash decision IDs cannot alias any of those. This
+cross-kind rule is atomic with the state mutation.
+
+## Receipt admission and bond gates
+
+`admit` consumes both a signed lifecycle admission event and one portable
+`misaka.palw.testnet-submission.v3` Receipt-v3 JSON file. The lifecycle event commits to the exact
+canonical receipt body, ML-DSA envelope, and public verification key. Admission independently checks:
+
+- Receipt-v3 version and ML-DSA-87 signature;
+- network, compute set, scheduler/node challenge, issue/expiry epochs, and replica slot;
+- key-derived registered credential and execution nullifier;
+- network-wide execution-nullifier single use;
+- distinct slot, credential, and execution identity for k=2;
+- exact match of every `MatchProjectionV2` consensus field.
+
+Assignment atomically locks the configured amount from both workers. Settlement preparation requires
+two active locks, no finalized slash, a matched pair, and an epoch strictly after the fraud window.
+A final slash consumes the complete affected assignment lock and prepares a full requester refund;
+it does not confirm that refund. Refund confirmation releases any remaining active lock. Released
+bonds retain their fraud/slash hold epoch. If a timeout refund is confirmed before that window
+closes, final slash evidence may still slash the released assignment while preserving the already
+confirmed refund state and command. Unbonding requires zero locked amount and an epoch strictly
+after the hold, so it cannot race this post-refund slash path.
+
+## SQLite behavior and recovery
+
+The dedicated database uses application ID `PALC`, schema version 1, a schema SHA3-256 fingerprint,
+foreign keys, WAL, `synchronous=FULL`, a 30-second busy timeout, and `BEGIN IMMEDIATE` for every
+mutation. The existing legacy `state_store` is intentionally not migrated: it uses 32-byte receipt
+identities, while Receipt v3 uses 64-byte identities.
+
+Initialization claims only an empty/unowned SQLite file. A database with application/user version
+zero but any existing user table is rejected without adding lifecycle objects or changing its
+application ID. Schema DDL, fingerprint, application ID, and user version commit in one explicit
+transaction, so a crash cannot leave a partially claimed lifecycle store.
+
+After a crash, reopen the same database and replay the exact signed event. Either the transaction was
+not committed and is applied once, or it was committed and returns `newly_applied:false`. Never edit
+the SQLite file or reconstruct a “close enough” event. Back up the database plus its current WAL using
+a SQLite-aware snapshot procedure.
+
+Concurrent conflicting terminal confirmations serialize. Exactly one can advance the prepared
+command; the loser observes a sequence/state/terminal conflict. Sending the exact same confirmation
+concurrently is safe: one applies and the other is an exact no-op replay if no later state advanced.
+
+## CLI workflow
+
+Build with Receipt-v3 verification enabled:
+
+```sh
+cargo build --release --features ml-dsa --bin palw-lifecycle
+```
+
+Initialize and bootstrap a public authority key:
+
+```sh
+palw-lifecycle init --db lifecycle.sqlite
+
+palw-lifecycle authority-add \
+  --db lifecycle.sqlite \
+  --network NETWORK_ID_128_HEX_CHARS \
+  --verifying-key ED25519_PUBLIC_KEY_64_HEX_CHARS \
+  --permissions funding,lifecycle,admission,terminal,bond,slash \
+  --valid-from 1 --valid-through 100000
+```
+
+Operational mutations use externally signed canonical event files. A file may contain raw canonical
+hex or this wrapper:
+
+```json
+{
+  "schema": "misaka.palw.lifecycle-event.v1",
+  "canonical_event_hex": "..."
+}
+```
+
+Create the `LifecycleEventBodyV1` with the library, obtain
+`LifecycleEventBodyV1::signing_digest()`, sign that 64-byte digest in the isolated authority signer,
+then assemble the public result with `SignedLifecycleEventV1::from_parts`. Finally encode it with
+`lifecycle_event_to_hex`. `from_parts` accepts only a body, public key ID, and completed signature; it
+does not accept a signing key.
+
+Each subcommand accepts an exact option allowlist. Unknown options, spelling mistakes, and private-key
+style options fail instead of being silently ignored.
+
+Apply events with a typed command (the command rejects a different event discriminant):
+
+```sh
+palw-lifecycle fund --db lifecycle.sqlite --event fund.event.json
+palw-lifecycle lock --db lifecycle.sqlite --event lock.event.json
+palw-lifecycle bond-fund --db lifecycle.sqlite --event worker-a-bond.event.json
+palw-lifecycle bond-fund --db lifecycle.sqlite --event worker-b-bond.event.json
+palw-lifecycle assign --db lifecycle.sqlite --event assignment.event.json
+palw-lifecycle admit --db lifecycle.sqlite --event receipt-a.event.json --receipt receipt-a.json
+palw-lifecycle admit --db lifecycle.sqlite --event receipt-b.event.json --receipt receipt-b.json
+palw-lifecycle prepare-settlement --db lifecycle.sqlite --event prepare.event.json
+palw-lifecycle confirm-settlement --db lifecycle.sqlite --event terminal-confirmation.event.json
+```
+
+Timeout/refund and bond operations use `timeout`, `confirm-refund`, `slash`, and `unbond`. `apply` is a
+generic equivalent when the caller already validates the expected event type.
+
+Inspect state:
+
+```sh
+palw-lifecycle status \
+  --db lifecycle.sqlite --network NETWORK_HEX --escrow ESCROW_HEX
+```
+
+Export is immutable (`create_new`) and refuses to overwrite an existing path:
+
+```sh
+palw-lifecycle export \
+  --db lifecycle.sqlite --network NETWORK_HEX --escrow ESCROW_HEX \
+  --out receipt-pair-bridge.json
+```
+
+For exact node Object-v2 bytes, supply selected-chain facts which the lifecycle database cannot
+infer (batch/leaf, provider bond outpoints, and both provider-owner authorizations):
+
+```sh
+palw-lifecycle export \
+  --db lifecycle.sqlite --network NETWORK_HEX --escrow ESCROW_HEX \
+  --node-context node-da-context.json \
+  --out receipt-da-object-v2.json
+```
+
+`node-da-context.json` uses schema `misaka.palw.node-da-object-v2-context.v1` and contains
+`network_id`, `batch_id`, `leaf_index`, `provider_{a,b}_bond`, the four Receipt-v3 leaf expectations,
+`private_match_commitment`, and `session_authorization_{a,b}`. Each authorization carries the node
+PALW `u32` network id, matching bond, exact owner/session ML-DSA-87 public keys, validity window,
+nonzero nonce, and owner signature. The deterministic non-value fixture and expected root are in
+`test-data/receipt_da_object_v2_golden_v1.json`. All three context object levels reject unknown JSON
+fields, so a misspelled selected-chain fact cannot be silently ignored.
+
+## Bridge and consensus status
+
+The bridge artifact contains both exact node-owned Receipt-v3 canonical bodies, ML-DSA envelopes,
+public verification keys, receipt IDs, execution nullifiers, the pair ID, and every fixed-16-KiB
+DA-01 chunk and Merkle proof.
+
+The chunk tree exactly mirrors the current DA-01 keyed-BLAKE2b-512 domains and length/index binding,
+so `da_chunk_algorithm_compatible` is true. A legacy export without `--node-context` retains the old
+lifecycle-local v1 payload and correctly reports `node_da_object_compatible: false`.
+
+With `--node-context`, the outer bytes are the node's canonical `PalwReceiptDaObjectV2`: two Receipt-v3
+submissions, two provider bond outpoints, two owner-to-session authorizations, and the verified k=2
+pair ID in exact node Borsh field order. Only this form reports:
+
+```json
+{
+  "consensus_enforced": false,
+  "node_receipt_v3_contract": "submit bridge_object.bytes_hex through ConsensusApi::palw_admit_da_object",
+  "node_admission_required": true,
+  "node_da_object_compatible": true
+}
+```
+
+Compatibility is not admission. The node API freezes one virtual sink, independently resolves the
+on-chain leaf and both provider records, re-verifies both owner authorizations and Receipt-v3
+signatures plus k=2 matching, and only then stores/publishes the object. The exported artifact keeps
+`consensus_enforced: false` until that node call succeeds, and it never claims that payment execution
+or value settlement is finalized by node consensus.
diff --git a/runtime-palw/src/bin/palw-integer-receipt.rs b/runtime-palw/src/bin/palw-integer-receipt.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aa10035867ccb3d4def9f83ad8274bc30f671aa1
--- /dev/null
+++ b/runtime-palw/src/bin/palw-integer-receipt.rs
@@ -0,0 +1,655 @@
+//! Self-issue a receipt for the canonical-integer Qwen3.6-35B engine (`qi35_model`).
+//!
+//! The receipt uses the node-owned v3 fixed-width wire contract, an ML-DSA-87 envelope,
+//! an XChaCha20Poly1305-sealed verification bundle, and durable `SQLite` state.
+//! Bit-exact integer execution lets independent machines form a valid k=2 pair.
+//!
+//! Usage: `palw-integer-receipt --prompt-stdin --replica-slot 0`
+//! `--audit-key-file RAW_32_BYTE_KEY --output-dir NEW_OR_EMPTY_DIR`
+//! `[--n-predict N] [--engine PATH] [--tables PATH] [--threads N] [--worker-label LABEL]`
+//!
+//! Honest scope: the job challenge is self-derived rather than beacon-assigned, the local
+//! ML-DSA credential must still be registered by the network lifecycle tooling, and the state
+//! database is not yet a unified network receipt ledger.
+
+use std::error::Error;
+use std::fmt;
+use std::fmt::Write as _;
+use std::io::Read;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use chacha20poly1305::aead::{Aead, KeyInit, Payload};
+use chacha20poly1305::{XChaCha20Poly1305, XNonce};
+use runtime_palw::receipt_v3::mldsa::{
+    sign_receipt_v3, verify_receipt_v3_self_consistent, verifying_key_and_credential_from_seed,
+};
+use runtime_palw::receipt_v3::{
+    domain_hash64, execution_nullifier_v3, output_commitment_v3, ComputeReceiptV3,
+    ImplementationTelemetry, MatchProjectionV2, RECEIPT_V3_VERSION,
+};
+use runtime_palw::semantic_cu::qwen36_semantic_compute_units;
+
+const SCHEMA: u16 = 3;
+const RULESET_ID: &str = "qi35-int-v1";
+const NETWORK_LABEL: &[u8] = b"MISAKA-Qwen-PALW-v1";
+const EOS_TOKEN: u32 = 248_046;
+const ISSUED_EPOCH: u64 = 1;
+const EXPIRES_EPOCH: u64 = 1_000_000;
+const MAX_PROMPT_BYTES: u64 = 1 << 20;
+
+#[derive(Debug)]
+struct PublicError(&'static str);
+impl fmt::Display for PublicError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+impl Error for PublicError {}
+
+fn hex(bytes: &[u8]) -> String {
+    let mut s = String::with_capacity(bytes.len() * 2);
+    for b in bytes {
+        write!(&mut s, "{b:02x}").expect("writing to String is infallible");
+    }
+    s
+}
+
+// mtime+size keyed cache => model hash costs ~0 after the first issuance ("seconds-scale receipts")
+fn blake2b256_file_cached(path: &Path) -> Result<[u8; 32], Box<dyn Error>> {
+    let meta = std::fs::metadata(path)?;
+    let mtime = meta
+        .modified()?
+        .duration_since(std::time::UNIX_EPOCH)?
+        .as_secs();
+    let key = format!("{}|{}|{}", path.display(), meta.len(), mtime);
+    let cache_path = std::env::temp_dir().join("qi35-hash-cache.txt");
+    if let Ok(cache) = std::fs::read_to_string(&cache_path) {
+        for line in cache.lines() {
+            if let Some(rest) = line.strip_prefix(&format!("{key}=")) {
+                if rest.len() == 64 {
+                    let mut out = [0u8; 32];
+                    for i in 0..32 {
+                        out[i] = u8::from_str_radix(&rest[2 * i..2 * i + 2], 16)?;
+                    }
+                    return Ok(out);
+                }
+            }
+        }
+    }
+    let h = blake2b256_file(path)?;
+    let mut cache = std::fs::read_to_string(&cache_path).unwrap_or_default();
+    writeln!(&mut cache, "{key}={}", hex(&h)).expect("writing to String is infallible");
+    let _ = std::fs::write(&cache_path, cache);
+    Ok(h)
+}
+
+fn blake2b256_file(path: &Path) -> Result<[u8; 32], Box<dyn Error>> {
+    let mut f = std::fs::File::open(path)?;
+    let mut hasher = blake2b_simd::Params::new().hash_length(32).to_state();
+    let mut buf = vec![0u8; 1 << 22];
+    loop {
+        let n = f.read(&mut buf)?;
+        if n == 0 {
+            break;
+        }
+        hasher.update(&buf[..n]);
+    }
+    let mut out = [0u8; 32];
+    out.copy_from_slice(hasher.finalize().as_bytes());
+    Ok(out)
+}
+
+fn ids_bytes(ids: &[u32]) -> Vec<u8> {
+    let mut v = Vec::with_capacity(ids.len() * 8);
+    for &i in ids {
+        v.extend_from_slice(&u64::from(i).to_le_bytes());
+    }
+    v
+}
+
+struct Cli {
+    prompt: String,
+    n_predict: u32,
+    output_directory: PathBuf,
+    audit_key_file: PathBuf,
+    engine: PathBuf,
+    tables: PathBuf,
+    threads: u32,
+    worker_label: String,
+    replica_slot: u8,
+    model_override: Option<PathBuf>,
+    prompt_ids_override: Option<Vec<u32>>,
+}
+
+#[allow(clippy::too_many_lines)]
+fn parse_cli() -> Result<Cli, Box<dyn Error>> {
+    let mut prompt_stdin = false;
+    let mut n_predict = 8u32;
+    let mut output_directory = None;
+    let mut audit_key_file = None;
+    let mut engine = None;
+    let mut tables = None;
+    let mut threads = 8u32;
+    let mut worker_label = "mac-local".to_owned();
+    let mut replica_slot = None;
+    let mut model_override = None;
+    let mut prompt_ids_override = None;
+    let mut arguments = std::env::args().skip(1);
+    while let Some(argument) = arguments.next() {
+        match argument.as_str() {
+            "--prompt-stdin" => prompt_stdin = true,
+            "--n-predict" => {
+                n_predict = arguments
+                    .next()
+                    .ok_or(PublicError("--n-predict requires a value"))?
+                    .parse()?;
+            }
+            "--output-dir" => {
+                output_directory = Some(PathBuf::from(
+                    arguments
+                        .next()
+                        .ok_or(PublicError("--output-dir requires a value"))?,
+                ));
+            }
+            "--audit-key-file" => {
+                audit_key_file = Some(PathBuf::from(
+                    arguments
+                        .next()
+                        .ok_or(PublicError("--audit-key-file requires a value"))?,
+                ));
+            }
+            "--engine" => {
+                engine = Some(PathBuf::from(
+                    arguments
+                        .next()
+                        .ok_or(PublicError("--engine requires a value"))?,
+                ));
+            }
+            "--tables" => {
+                tables = Some(PathBuf::from(
+                    arguments
+                        .next()
+                        .ok_or(PublicError("--tables requires a value"))?,
+                ));
+            }
+            "--threads" => {
+                threads = arguments
+                    .next()
+                    .ok_or(PublicError("--threads requires a value"))?
+                    .parse()?;
+            }
+            "--worker-label" => {
+                worker_label = arguments
+                    .next()
+                    .ok_or(PublicError("--worker-label requires a value"))?;
+            }
+            "--replica-slot" => {
+                let slot: u8 = arguments
+                    .next()
+                    .ok_or(PublicError("--replica-slot requires 0 or 1"))?
+                    .parse()?;
+                if slot > 1 {
+                    return Err(PublicError("--replica-slot must be 0 or 1").into());
+                }
+                replica_slot = Some(slot);
+            }
+            "--model" => {
+                model_override = Some(PathBuf::from(
+                    arguments
+                        .next()
+                        .ok_or(PublicError("--model requires a value"))?,
+                ));
+            }
+            "--prompt-ids" => {
+                let csv = arguments
+                    .next()
+                    .ok_or(PublicError("--prompt-ids requires a value"))?;
+                let ids: Result<Vec<u32>, _> = csv.split(',').map(str::parse).collect();
+                prompt_ids_override =
+                    Some(ids.map_err(|_| {
+                        PublicError("--prompt-ids must be comma-separated integers")
+                    })?);
+            }
+            "--help" | "-h" => {
+                println!(
+                    "usage: palw-integer-receipt --prompt-stdin --audit-key-file RAW_32_BYTE_KEY \
+                     --output-dir NEW_OR_EMPTY_DIR [--n-predict N] [--engine PATH] [--tables PATH] \
+                     --replica-slot 0|1 [--threads N] [--worker-label LABEL]"
+                );
+                std::process::exit(0);
+            }
+            _ => return Err(PublicError("unknown command-line argument").into()),
+        }
+    }
+    let mut prompt = String::new();
+    if prompt_ids_override.is_none() {
+        if !prompt_stdin {
+            return Err(PublicError("--prompt-stdin (or --prompt-ids) is required").into());
+        }
+        std::io::stdin()
+            .lock()
+            .take(MAX_PROMPT_BYTES + 1)
+            .read_to_string(&mut prompt)?;
+        if u64::try_from(prompt.len())? > MAX_PROMPT_BYTES || prompt.is_empty() {
+            return Err(PublicError("prompt must be non-empty and at most 1 MiB").into());
+        }
+    }
+    let env_or = |key: &str, fallback: Option<PathBuf>| -> Result<PathBuf, Box<dyn Error>> {
+        if let Some(p) = fallback {
+            return Ok(p);
+        }
+        std::env::var(key)
+            .map(PathBuf::from)
+            .map_err(|_| PublicError("engine/tables path missing (flag or env)").into())
+    };
+    Ok(Cli {
+        prompt,
+        n_predict: n_predict.clamp(1, 1024),
+        output_directory: output_directory.ok_or(PublicError("--output-dir is required"))?,
+        audit_key_file: audit_key_file.ok_or(PublicError("--audit-key-file is required"))?,
+        engine: env_or("QI35_ENGINE", engine)?,
+        tables: env_or("QI35_TABLES", tables)?,
+        threads,
+        worker_label,
+        replica_slot: replica_slot.ok_or(PublicError("--replica-slot is required"))?,
+        model_override,
+        prompt_ids_override,
+    })
+}
+
+fn tokenize_prompt(
+    tokenizer: &Path,
+    model: &Path,
+    prompt: &str,
+) -> Result<Vec<u32>, Box<dyn Error>> {
+    use std::io::Write;
+    let mut child = Command::new(tokenizer)
+        .arg("--offline")
+        .arg("--model")
+        .arg(model)
+        .arg("--stdin")
+        .arg("--ids")
+        .stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .spawn()?;
+    child
+        .stdin
+        .take()
+        .ok_or(PublicError("tokenizer stdin missing"))?
+        .write_all(prompt.as_bytes())?;
+    let output = child.wait_with_output()?;
+    if !output.status.success() {
+        return Err(PublicError("pinned tokenizer exited unsuccessfully").into());
+    }
+    let stdout = std::str::from_utf8(&output.stdout)?;
+    let line = stdout
+        .lines()
+        .find(|line| line.trim_start().starts_with('['))
+        .ok_or(PublicError("tokenizer emitted no ID array"))?;
+    Ok(serde_json::from_str(line.trim())?)
+}
+
+struct EngineRun {
+    output_ids: Vec<u32>,
+    eos_reached: bool,
+    route_root: [u8; 32],
+    kv_root: [u8; 32],
+    state_root: [u8; 32],
+    seconds: f64,
+}
+
+fn run_engine(cli: &Cli, model: &Path, prompt_ids: &[u32]) -> Result<EngineRun, Box<dyn Error>> {
+    let ids_csv = prompt_ids
+        .iter()
+        .map(u32::to_string)
+        .collect::<Vec<_>>()
+        .join(",");
+    let started = std::time::Instant::now();
+    let extra = std::env::var("QI35_ENGINE_ARGS").unwrap_or_default();
+    let output = Command::new(&cli.engine)
+        .arg(model)
+        .arg(&cli.tables)
+        .args(["--ids", &ids_csv])
+        .args(["--max-new", &cli.n_predict.to_string()])
+        .args(["--eos", &EOS_TOKEN.to_string()])
+        .args(["--threads", &cli.threads.to_string()])
+        .args(extra.split_whitespace())
+        .output()?;
+    if !output.status.success() {
+        return Err(PublicError("integer engine exited unsuccessfully").into());
+    }
+    let seconds = started.elapsed().as_secs_f64();
+    let stdout = std::str::from_utf8(&output.stdout)?;
+    let mut output_ids = None;
+    let mut eos_reached = None;
+    let mut roots: [Option<[u8; 32]>; 3] = [None, None, None];
+    let parse_hex32 = |s: &str| -> Option<[u8; 32]> {
+        let s = s.trim();
+        if s.len() != 64 {
+            return None;
+        }
+        let mut out = [0u8; 32];
+        for i in 0..32 {
+            out[i] = u8::from_str_radix(&s[2 * i..2 * i + 2], 16).ok()?;
+        }
+        Some(out)
+    };
+    for line in stdout.lines() {
+        if let Some(rest) = line.strip_prefix("generated = ") {
+            let cleaned = rest.trim().trim_start_matches('[').trim_end_matches(']');
+            let ids: Vec<u32> = cleaned
+                .split(',')
+                .map(str::trim)
+                .filter(|s| !s.is_empty())
+                .map(str::parse)
+                .collect::<Result<_, _>>()?;
+            output_ids = Some(ids);
+        } else if let Some(rest) = line.strip_prefix("eos_reached = ") {
+            eos_reached = Some(rest.trim() == "true");
+        } else if let Some(rest) = line.strip_prefix("route_root = ") {
+            roots[0] = parse_hex32(rest);
+        } else if let Some(rest) = line.strip_prefix("kv_root = ") {
+            roots[1] = parse_hex32(rest);
+        } else if let Some(rest) = line.strip_prefix("state_root = ") {
+            roots[2] = parse_hex32(rest);
+        }
+    }
+    Ok(EngineRun {
+        output_ids: output_ids.ok_or(PublicError("engine emitted no generated ids"))?,
+        eos_reached: eos_reached.ok_or(PublicError("engine emitted no eos flag"))?,
+        route_root: roots[0].ok_or(PublicError("engine emitted no route root"))?,
+        kv_root: roots[1].ok_or(PublicError("engine emitted no kv root"))?,
+        state_root: roots[2].ok_or(PublicError("engine emitted no state root"))?,
+        seconds,
+    })
+}
+
+fn main() {
+    if let Err(error) = run() {
+        eprintln!("palw-integer-receipt: {error}");
+        std::process::exit(1);
+    }
+}
+
+#[allow(clippy::too_many_lines)]
+fn run() -> Result<(), Box<dyn Error>> {
+    let workspace = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .ok_or(PublicError("runtime crate has no workspace parent"))?;
+    let cli = parse_cli()?;
+    std::fs::create_dir_all(&cli.output_directory)?;
+
+    let audit_key = std::fs::read(&cli.audit_key_file)?;
+    if audit_key.len() != 32 {
+        return Err(PublicError("audit key must be exactly 32 raw bytes").into());
+    }
+
+    let model = cli.model_override.clone().unwrap_or_else(|| {
+        workspace.join(
+            "models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+        )
+    });
+    let prompt_ids = if let Some(ids) = &cli.prompt_ids_override {
+        ids.clone()
+    } else {
+        let tokenizer = workspace.join("vendor/llama.cpp/build-palw/bin/llama-tokenize");
+        tokenize_prompt(&tokenizer, &model, &cli.prompt)?
+    };
+    if prompt_ids.is_empty() {
+        return Err(PublicError("prompt token list is empty").into());
+    }
+
+    eprintln!("hashing artifacts (model/tables/engine, blake2b256)...");
+    let model_hash = blake2b256_file_cached(&model)?;
+    let tables_hash = blake2b256_file_cached(&cli.tables)?;
+    let engine_hash = blake2b256_file_cached(&cli.engine)?;
+
+    eprintln!(
+        "running canonical integer engine ({} prompt tokens, n_predict {})...",
+        prompt_ids.len(),
+        cli.n_predict
+    );
+    let run = run_engine(&cli, &model, &prompt_ids)?;
+    eprintln!(
+        "engine done: {} output tokens in {:.2}s",
+        run.output_ids.len(),
+        run.seconds
+    );
+
+    // ---- consensus projection (all Hash64, byte-equal across backends) ----
+    let network_id = domain_hash64("qi35-network/v3", SCHEMA, &[NETWORK_LABEL]);
+    let prompt_commitment = domain_hash64(
+        "qi35-prompt/v3",
+        SCHEMA,
+        &[&network_id, &ids_bytes(&prompt_ids)],
+    );
+    let compute_set_id = domain_hash64(
+        "qi35-compute-set/v3",
+        SCHEMA,
+        &[&model_hash, &tables_hash, RULESET_ID.as_bytes()],
+    );
+    // honest v0: self-derived challenge (no epoch beacon yet); equal across replicas by design
+    let job_challenge = domain_hash64(
+        "qi35-self-challenge/v3",
+        SCHEMA,
+        &[
+            &network_id,
+            &prompt_commitment,
+            &cli.n_predict.to_le_bytes(),
+        ],
+    );
+    let output_commitment = output_commitment_v3(&run.output_ids, &job_challenge);
+    let schedule_root = domain_hash64(
+        "qi35-schedule/v3",
+        SCHEMA,
+        &[
+            RULESET_ID.as_bytes(),
+            &(prompt_ids.len() as u64).to_le_bytes(),
+            &u64::from(cli.n_predict).to_le_bytes(),
+            &u64::from(EOS_TOKEN).to_le_bytes(),
+        ],
+    );
+    let execution_root = domain_hash64("qi35-exec-kv/v3", SCHEMA, &[&run.kv_root]);
+    let route_root = domain_hash64("qi35-exec-route/v3", SCHEMA, &[&run.route_root]);
+    let state_root = domain_hash64("qi35-exec-state/v3", SCHEMA, &[&run.state_root]);
+    let prefill = u32::try_from(prompt_ids.len())?;
+    let generated = u32::try_from(run.output_ids.len())?;
+    let canonical_compute_units = qwen36_semantic_compute_units(prefill, generated);
+    let projection = MatchProjectionV2 {
+        compute_set_id,
+        job_challenge,
+        output_commitment,
+        schedule_root,
+        execution_root,
+        route_root,
+        state_root,
+        canonical_compute_units,
+        token_count: u64::from(prefill) + u64::from(generated),
+        stop_reason: if run.eos_reached { 1 } else { 2 },
+    };
+
+    // ---- worker credential: ML-DSA-87 key derived from audit key + worker label (v0) ----
+    let seed64 = domain_hash64(
+        "qi35-mldsa-seed/v1",
+        SCHEMA,
+        &[&audit_key, cli.worker_label.as_bytes()],
+    );
+    let mut seed = [0u8; 32];
+    seed.copy_from_slice(&seed64[..32]);
+    let (_verifying_key, worker_credential_id) = verifying_key_and_credential_from_seed(&seed);
+
+    let timestamp_millis =
+        u64::try_from(SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis())?;
+    let execution_nullifier = execution_nullifier_v3(
+        &network_id,
+        &compute_set_id,
+        &job_challenge,
+        &worker_credential_id,
+        cli.replica_slot,
+        ISSUED_EPOCH,
+    );
+
+    let receipt = ComputeReceiptV3 {
+        receipt_version: RECEIPT_V3_VERSION,
+        network_id,
+        projection,
+        telemetry: ImplementationTelemetry {
+            runtime_class_id: {
+                let d = domain_hash64("qi35-runtime-class/v0", SCHEMA, &[b"rust-cpu-integer"]);
+                let mut t = [0u8; 32];
+                t.copy_from_slice(&d[..32]);
+                t
+            },
+            runtime_manifest_hash: engine_hash,
+        },
+        worker_credential_id,
+        replica_slot: cli.replica_slot,
+        execution_nullifier,
+        issued_epoch: ISSUED_EPOCH,
+        expires_epoch: EXPIRES_EPOCH,
+    };
+    let (envelope, vk_bytes) = sign_receipt_v3(&receipt, &seed, worker_credential_id)
+        .map_err(|_| PublicError("ML-DSA signing failed"))?;
+    verify_receipt_v3_self_consistent(&receipt, &envelope, &vk_bytes)
+        .map_err(|_| PublicError("self-verification of the fresh receipt failed"))?;
+    let receipt_id = receipt.receipt_id();
+
+    // ---- public receipt JSON (no ids, no key material besides the public vk) ----
+    let public = serde_json::json!({
+        "schema": "palw.integer-receipt/v3-envelope",
+        "class": "canonical_integer_v0",
+        "receipt_version": 3,
+        "network_id": hex(&receipt.network_id),
+        "receipt_id": hex(&receipt_id),
+        "projection": {
+            "compute_set_id": hex(&receipt.projection.compute_set_id),
+            "job_challenge": hex(&receipt.projection.job_challenge),
+            "output_commitment": hex(&receipt.projection.output_commitment),
+            "schedule_root": hex(&receipt.projection.schedule_root),
+            "execution_root": hex(&receipt.projection.execution_root),
+            "route_root": hex(&receipt.projection.route_root),
+            "state_root": hex(&receipt.projection.state_root),
+            "canonical_compute_units": receipt.projection.canonical_compute_units,
+            "token_count": receipt.projection.token_count,
+            "stop_reason": receipt.projection.stop_reason,
+        },
+        "telemetry": {
+            "runtime_class_id": hex(&receipt.telemetry.runtime_class_id),
+            "runtime_manifest_hash": hex(&receipt.telemetry.runtime_manifest_hash),
+        },
+        "worker_credential_id": hex(&receipt.worker_credential_id),
+        "replica_slot": receipt.replica_slot,
+        "execution_nullifier": hex(&receipt.execution_nullifier),
+        "issued_epoch": receipt.issued_epoch,
+        "expires_epoch": receipt.expires_epoch,
+        "envelope": {
+            "body_digest": hex(&envelope.body_digest),
+            "algorithm": envelope.algorithm,
+            "signer_credential_id": hex(&envelope.signer_credential_id),
+            "signature": hex(&envelope.signature),
+        },
+        "verifying_key": hex(&vk_bytes),
+        "artifacts": {
+            "model_blake2b256": hex(&model_hash),
+            "tables_blake2b256": hex(&tables_hash),
+            "engine_blake2b256": hex(&engine_hash),
+            "ruleset_id": RULESET_ID,
+        },
+        "prompt_tokens": prefill,
+        "output_tokens": generated,
+        "worker_label": cli.worker_label,
+        "timestamp_millis": timestamp_millis,
+        "engine_seconds": run.seconds,
+    });
+    let public_bytes = serde_json::to_vec_pretty(&public)?;
+
+    // ---- sealed verification bundle (opening): XChaCha20Poly1305, AAD = receipt_id ----
+    let opening = serde_json::json!({
+        "prompt_ids": prompt_ids,
+        "output_ids": run.output_ids,
+        "engine_route_digest": hex(&run.route_root),
+        "engine_kv_digest": hex(&run.kv_root),
+        "engine_state_digest": hex(&run.state_root),
+        "n_predict": cli.n_predict,
+        "threads": cli.threads,
+        "worker_label": cli.worker_label,
+    });
+    let key64 = domain_hash64("qi35-bundle-key/v1", SCHEMA, &[&audit_key, &receipt_id]);
+    let nonce64 = domain_hash64(
+        "qi35-bundle-nonce/v1",
+        SCHEMA,
+        &[&receipt_id, &timestamp_millis.to_le_bytes()],
+    );
+    let cipher = XChaCha20Poly1305::new_from_slice(&key64[..32])
+        .map_err(|_| PublicError("bundle key derivation failed"))?;
+    let nonce = XNonce::from_slice(&nonce64[..24]);
+    let ciphertext = cipher
+        .encrypt(
+            nonce,
+            Payload {
+                msg: &serde_json::to_vec(&opening)?,
+                aad: &receipt_id,
+            },
+        )
+        .map_err(|_| PublicError("bundle sealing failed"))?;
+    let mut bundle = Vec::new();
+    bundle.extend_from_slice(b"QI35BND1");
+    bundle.extend_from_slice(&receipt_id);
+    bundle.extend_from_slice(&nonce64[..24]);
+    bundle.extend_from_slice(&ciphertext);
+
+    // ---- durable state-db (dedicated integer-receipt table; nullifier UNIQUE) ----
+    let db_path = cli.output_directory.join("qi35-state.sqlite3");
+    let conn = rusqlite::Connection::open(&db_path)?;
+    conn.execute_batch(
+        "PRAGMA journal_mode=WAL;
+         CREATE TABLE IF NOT EXISTS integer_receipts (
+             receipt_id TEXT PRIMARY KEY,
+             execution_nullifier TEXT UNIQUE NOT NULL,
+             worker_credential_id TEXT NOT NULL,
+             output_commitment TEXT NOT NULL,
+             timestamp_millis INTEGER NOT NULL,
+             public_json TEXT NOT NULL,
+             bundle BLOB NOT NULL
+         );",
+    )?;
+    conn.execute(
+        "INSERT INTO integer_receipts \
+         (receipt_id, execution_nullifier, worker_credential_id, output_commitment, timestamp_millis, public_json, bundle) \
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
+        rusqlite::params![
+            hex(&receipt_id),
+            hex(&execution_nullifier),
+            hex(&worker_credential_id),
+            hex(&receipt.projection.output_commitment),
+            timestamp_millis,
+            String::from_utf8(public_bytes.clone())?,
+            bundle,
+        ],
+    )?;
+    let durable: u64 = conn.query_row("SELECT COUNT(*) FROM integer_receipts", [], |r| r.get(0))?;
+
+    let rid_hex = hex(&receipt_id);
+    let receipt_path = cli.output_directory.join(format!("{rid_hex}.integer.json"));
+    let bundle_path = cli
+        .output_directory
+        .join(format!("{rid_hex}.integer.bundle"));
+    std::fs::write(&receipt_path, &public_bytes)?;
+    std::fs::write(&bundle_path, &bundle)?;
+
+    println!("receipt_id={rid_hex}");
+    println!("receipt={}", receipt_path.display());
+    println!("verification_bundle={}", bundle_path.display());
+    println!("state_db={}", db_path.display());
+    println!(
+        "output_commitment={}",
+        hex(&receipt.projection.output_commitment)
+    );
+    println!("canonical_compute_units={canonical_compute_units}");
+    println!("signature=ml-dsa-87 (receipt-v3 envelope)");
+    println!("durable_receipt_count={durable}");
+    Ok(())
+}
diff --git a/runtime-palw/src/bin/palw-lifecycle.rs b/runtime-palw/src/bin/palw-lifecycle.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a2f4cd0ba518d1d6bfc1e707331375f51615c716
--- /dev/null
+++ b/runtime-palw/src/bin/palw-lifecycle.rs
@@ -0,0 +1,303 @@
+//! Operational CLI for the durable PALW Receipt-v3 lifecycle control plane.
+//!
+//! All mutations consume externally signed canonical events. This binary has no private-key,
+//! signing-seed, or secret-environment input path.
+
+#![allow(clippy::too_many_lines)]
+
+use ed25519_dalek::VerifyingKey;
+use runtime_palw::lifecycle::{
+    lifecycle_event_from_hex, lifecycle_hash64_from_hex, LifecycleAuthorityRecord,
+    LifecycleEventPayloadV1, LifecyclePermissions, LifecycleStore, SignedLifecycleEventV1,
+};
+use runtime_palw::receipt::signer_key_id;
+use runtime_palw::testnet::import_receipt;
+use std::collections::BTreeMap;
+use std::io::Write as _;
+
+fn usage(exit_code: i32) -> ! {
+    eprintln!(
+        "usage:\n\
+         \x20 palw-lifecycle init --db FILE\n\
+         \x20 palw-lifecycle authority-add --db FILE --network HEX128 --verifying-key HEX64 \\\n         \x20     --permissions funding,lifecycle,admission,terminal,bond,slash \\\n         \x20     --valid-from EPOCH --valid-through EPOCH [--revoked-at EPOCH]\n\
+         \x20 palw-lifecycle <apply|fund|lock|bond-fund|assign|admit|prepare-settlement|\n\
+         \x20     confirm-settlement|timeout|confirm-refund|slash|unbond> \\\n         \x20     --db FILE --event FILE [--receipt RECEIPT_JSON]\n\
+         \x20 palw-lifecycle status --db FILE --network HEX128 --escrow HEX128\n\
+         \x20 palw-lifecycle export --db FILE --network HEX128 --escrow HEX128 --out FILE \\\n         \x20     [--node-context SELECTED_CHAIN_CONTEXT_JSON]\n\
+         \n\
+         event FILE is strict canonical envelope hex, or JSON with canonical_event_hex.\n\
+         Receipt-v3 admission requires --receipt. Export uses create-new and never overwrites;\n\
+         --node-context emits exact node PalwReceiptDaObjectV2 bytes.\n\
+         No command accepts private/signing key material."
+    );
+    std::process::exit(exit_code);
+}
+
+fn die(message: impl std::fmt::Display) -> ! {
+    eprintln!("palw-lifecycle: {message}");
+    std::process::exit(1);
+}
+
+fn parse_flags(args: &[String]) -> BTreeMap<String, String> {
+    let mut flags = BTreeMap::new();
+    let mut index = 0;
+    while index < args.len() {
+        let key = args[index].as_str();
+        if !key.starts_with("--") || index + 1 >= args.len() {
+            usage(2);
+        }
+        if flags
+            .insert(key.to_string(), args[index + 1].clone())
+            .is_some()
+        {
+            die(format!("duplicate option {key}"));
+        }
+        index += 2;
+    }
+    flags
+}
+
+fn validate_flags(flags: &BTreeMap<String, String>, allowed: &[&str]) {
+    for key in flags.keys() {
+        if !allowed.contains(&key.as_str()) {
+            die(format!("unknown or forbidden option {key}"));
+        }
+    }
+}
+
+fn required<'a>(flags: &'a BTreeMap<String, String>, key: &str) -> &'a str {
+    flags.get(key).map_or_else(|| usage(2), String::as_str)
+}
+
+fn parse_u64(flags: &BTreeMap<String, String>, key: &str) -> u64 {
+    required(flags, key)
+        .parse()
+        .unwrap_or_else(|_| die(format!("{key} must be a u64")))
+}
+
+fn unhex(value: &str) -> Option<Vec<u8>> {
+    if value.len() % 2 != 0 || !value.bytes().all(|byte| byte.is_ascii_hexdigit()) {
+        return None;
+    }
+    (0..value.len() / 2)
+        .map(|index| u8::from_str_radix(&value[2 * index..2 * index + 2], 16).ok())
+        .collect()
+}
+
+fn hex(bytes: &[u8]) -> String {
+    use std::fmt::Write as _;
+    bytes
+        .iter()
+        .fold(String::with_capacity(bytes.len() * 2), |mut out, byte| {
+            let _ = write!(out, "{byte:02x}");
+            out
+        })
+}
+
+fn read_event(path: &str) -> SignedLifecycleEventV1 {
+    let text = std::fs::read_to_string(path)
+        .unwrap_or_else(|error| die(format!("cannot read signed event {path}: {error}")));
+    let trimmed = text.trim();
+    let hex = if trimmed.starts_with('{') {
+        let value: serde_json::Value = serde_json::from_str(trimmed)
+            .unwrap_or_else(|error| die(format!("invalid event JSON wrapper: {error}")));
+        if value.get("schema").and_then(serde_json::Value::as_str)
+            != Some("misaka.palw.lifecycle-event.v1")
+        {
+            die("event JSON wrapper has the wrong schema");
+        }
+        value
+            .get("canonical_event_hex")
+            .and_then(serde_json::Value::as_str)
+            .unwrap_or_else(|| die("event JSON wrapper lacks canonical_event_hex"))
+            .to_string()
+    } else {
+        trimmed.to_string()
+    };
+    lifecycle_event_from_hex(&hex).unwrap_or_else(|error| die(error))
+}
+
+fn event_command(payload: &LifecycleEventPayloadV1) -> &'static str {
+    match payload {
+        LifecycleEventPayloadV1::FundingConfirmed { .. } => "fund",
+        LifecycleEventPayloadV1::EscrowLocked { .. } => "lock",
+        LifecycleEventPayloadV1::BondFunded { .. } => "bond-fund",
+        LifecycleEventPayloadV1::Assigned { .. } => "assign",
+        LifecycleEventPayloadV1::ReceiptAdmitted { .. } => "admit",
+        LifecycleEventPayloadV1::SettlementPrepared { .. } => "prepare-settlement",
+        LifecycleEventPayloadV1::SettlementConfirmed { .. } => "confirm-settlement",
+        LifecycleEventPayloadV1::TimeoutRefundPrepared { .. } => "timeout",
+        LifecycleEventPayloadV1::RefundConfirmed { .. } => "confirm-refund",
+        LifecycleEventPayloadV1::SlashFinalized { .. } => "slash",
+        LifecycleEventPayloadV1::UnbondConfirmed { .. } => "unbond",
+    }
+}
+
+fn permissions(value: &str) -> LifecyclePermissions {
+    let mut bits = 0_u8;
+    for permission in value.split(',') {
+        bits |= match permission {
+            "funding" => LifecyclePermissions::FUNDING,
+            "lifecycle" => LifecyclePermissions::LIFECYCLE,
+            "admission" => LifecyclePermissions::ADMISSION,
+            "terminal" => LifecyclePermissions::TERMINAL,
+            "bond" => LifecyclePermissions::BOND,
+            "slash" => LifecyclePermissions::SLASH,
+            _ => die(format!("unknown permission {permission}")),
+        };
+    }
+    LifecyclePermissions::new(bits).unwrap_or_else(|error| die(error))
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    if args.is_empty() || matches!(args[0].as_str(), "--help" | "-h") {
+        usage(if args.is_empty() { 2 } else { 0 });
+    }
+    let command = args[0].as_str();
+    let flags = parse_flags(&args[1..]);
+    let allowed = match command {
+        "init" => &["--db"][..],
+        "authority-add" => &[
+            "--db",
+            "--network",
+            "--verifying-key",
+            "--permissions",
+            "--valid-from",
+            "--valid-through",
+            "--revoked-at",
+        ][..],
+        "status" => &["--db", "--network", "--escrow"][..],
+        "export" => &["--db", "--network", "--escrow", "--out", "--node-context"][..],
+        "apply" | "admit" => &["--db", "--event", "--receipt"][..],
+        "fund" | "lock" | "bond-fund" | "assign" | "prepare-settlement" | "confirm-settlement"
+        | "timeout" | "confirm-refund" | "slash" | "unbond" => &["--db", "--event"][..],
+        _ => usage(2),
+    };
+    validate_flags(&flags, allowed);
+    let db = required(&flags, "--db");
+    match command {
+        "init" => {
+            if flags.len() != 1 {
+                usage(2);
+            }
+            LifecycleStore::open(db).unwrap_or_else(|error| die(error));
+            println!("{{\"schema\":\"misaka.palw.lifecycle-init.v1\",\"initialized\":true}}");
+        }
+        "authority-add" => {
+            let network_id = lifecycle_hash64_from_hex(required(&flags, "--network"))
+                .unwrap_or_else(|| die("--network must be exactly 64 bytes of hex"));
+            let key: [u8; 32] = unhex(required(&flags, "--verifying-key"))
+                .and_then(|bytes| bytes.try_into().ok())
+                .unwrap_or_else(|| die("--verifying-key must be exactly 32 bytes of hex"));
+            let verifying_key = VerifyingKey::from_bytes(&key)
+                .unwrap_or_else(|_| die("invalid Ed25519 verifying key"));
+            let record = LifecycleAuthorityRecord {
+                network_id,
+                verifying_key,
+                valid_from_epoch: parse_u64(&flags, "--valid-from"),
+                valid_through_epoch: parse_u64(&flags, "--valid-through"),
+                revoked_at_epoch: flags.get("--revoked-at").map(|value| {
+                    value
+                        .parse()
+                        .unwrap_or_else(|_| die("invalid --revoked-at"))
+                }),
+                permissions: permissions(required(&flags, "--permissions")),
+            };
+            let key_id = signer_key_id(&record.verifying_key);
+            let mut store = LifecycleStore::open(db).unwrap_or_else(|error| die(error));
+            let inserted = store
+                .register_authority(&record)
+                .unwrap_or_else(|error| die(error));
+            println!(
+                "{}",
+                serde_json::json!({
+                    "schema": "misaka.palw.lifecycle-authority-result.v1",
+                    "authority_key_id": hex(&key_id),
+                    "newly_registered": inserted,
+                })
+            );
+        }
+        "status" => {
+            let network = lifecycle_hash64_from_hex(required(&flags, "--network"))
+                .unwrap_or_else(|| die("invalid --network"));
+            let escrow = lifecycle_hash64_from_hex(required(&flags, "--escrow"))
+                .unwrap_or_else(|| die("invalid --escrow"));
+            let store = LifecycleStore::open(db).unwrap_or_else(|error| die(error));
+            println!(
+                "{}",
+                store
+                    .escrow_status_json(&network, &escrow)
+                    .unwrap_or_else(|error| die(error))
+            );
+        }
+        "export" => {
+            let network = lifecycle_hash64_from_hex(required(&flags, "--network"))
+                .unwrap_or_else(|| die("invalid --network"));
+            let escrow = lifecycle_hash64_from_hex(required(&flags, "--escrow"))
+                .unwrap_or_else(|| die("invalid --escrow"));
+            let out = required(&flags, "--out");
+            let store = LifecycleStore::open(db).unwrap_or_else(|error| die(error));
+            let node_context = flags.get("--node-context");
+            let artifact = if let Some(path) = node_context {
+                let context_json = std::fs::read_to_string(path).unwrap_or_else(|error| {
+                    die(format!("cannot read node context {path}: {error}"))
+                });
+                store
+                    .export_node_da_object_v2_json(&network, &escrow, &context_json)
+                    .unwrap_or_else(|error| die(error))
+            } else {
+                store
+                    .export_bridge_json(&network, &escrow)
+                    .unwrap_or_else(|error| die(error))
+            };
+            let mut file = std::fs::OpenOptions::new()
+                .write(true)
+                .create_new(true)
+                .open(out)
+                .unwrap_or_else(|error| die(format!("refusing/cannot create {out}: {error}")));
+            file.write_all(artifact.as_bytes())
+                .and_then(|()| file.sync_all())
+                .unwrap_or_else(|error| die(format!("cannot durably write {out}: {error}")));
+            println!(
+                "{}",
+                serde_json::json!({
+                    "schema": "misaka.palw.lifecycle-export-result.v1",
+                    "path": out,
+                    "consensus_enforced": false,
+                    "node_da_object_compatible": node_context.is_some(),
+                })
+            );
+        }
+        "apply" | "fund" | "lock" | "bond-fund" | "assign" | "admit" | "prepare-settlement"
+        | "confirm-settlement" | "timeout" | "confirm-refund" | "slash" | "unbond" => {
+            let event = read_event(required(&flags, "--event"));
+            let actual = event_command(&event.body.payload);
+            if command != "apply" && command != actual {
+                die(format!("{command} rejects typed {actual} event"));
+            }
+            let receipt = flags.get("--receipt").map(|path| {
+                let json = std::fs::read_to_string(path)
+                    .unwrap_or_else(|error| die(format!("cannot read receipt {path}: {error}")));
+                import_receipt(&json).unwrap_or_else(|| die("malformed Receipt-v3 submission"))
+            });
+            let mut store = LifecycleStore::open(db).unwrap_or_else(|error| die(error));
+            let outcome = store
+                .apply_event(&event, receipt.as_ref())
+                .unwrap_or_else(|error| die(error));
+            println!(
+                "{}",
+                serde_json::json!({
+                    "schema": "misaka.palw.lifecycle-apply-result.v1",
+                    "event_id": hex(&outcome.event_id),
+                    "newly_applied": outcome.newly_applied,
+                    "sequence": outcome.sequence,
+                    "state_tag": outcome.state,
+                    "payment_command_id": outcome.payment_command_id.map(|value| hex(&value)),
+                    "consensus_enforced": false,
+                })
+            );
+        }
+        _ => usage(2),
+    }
+}
diff --git a/runtime-palw/src/bin/palw-verify-integer.rs b/runtime-palw/src/bin/palw-verify-integer.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ef1070e78302ce4c31081a051f5e9daaafff1ac1
--- /dev/null
+++ b/runtime-palw/src/bin/palw-verify-integer.rs
@@ -0,0 +1,541 @@
+//! Verify a canonical-integer receipt issued by `palw-integer-receipt`.
+//!
+//! Verification is fail-closed across the ML-DSA-87 envelope, receipt ID,
+//! credential binding, encrypted audit opening, projection commitments, optional
+//! `SQLite` state, optional deterministic rerun, and optional k=2 pair matching.
+//!
+//! Usage: `palw-verify-integer --receipt FILE.json --bundle FILE.bundle`
+//! `--audit-key-file KEY [--state-db FILE]`
+//! `[--rerun --engine PATH --tables PATH [--threads N]] [--pair OTHER.json]`
+
+use std::error::Error;
+use std::fmt;
+use std::fmt::Write as _;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use chacha20poly1305::aead::{Aead, KeyInit, Payload};
+use chacha20poly1305::{XChaCha20Poly1305, XNonce};
+use runtime_palw::receipt_v3::mldsa::verify_receipt_v3_self_consistent;
+use runtime_palw::receipt_v3::{
+    credential_id_from_verifying_key, domain_hash64, match_pair_v3, output_commitment_v3, Hash64,
+};
+use runtime_palw::semantic_cu::qwen36_semantic_compute_units;
+use runtime_palw::testnet::{import_receipt, SubmissionV3};
+
+const SCHEMA: u16 = 3;
+const RULESET_ID: &str = "qi35-int-v1";
+const NETWORK_LABEL: &[u8] = b"MISAKA-Qwen-PALW-v1";
+const EOS_TOKEN: u32 = 248_046;
+
+#[derive(Debug)]
+struct PublicError(String);
+impl fmt::Display for PublicError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+impl Error for PublicError {}
+fn err(msg: impl Into<String>) -> Box<dyn Error> {
+    Box::new(PublicError(msg.into()))
+}
+
+fn unhex(s: &str) -> Result<Vec<u8>, Box<dyn Error>> {
+    if s.len() % 2 != 0 {
+        return Err(err("odd hex length"));
+    }
+    (0..s.len() / 2)
+        .map(|i| u8::from_str_radix(&s[2 * i..2 * i + 2], 16).map_err(|_| err("bad hex")))
+        .collect()
+}
+fn unhex32(s: &str) -> Result<[u8; 32], Box<dyn Error>> {
+    let v = unhex(s)?;
+    let mut out = [0u8; 32];
+    if v.len() != 32 {
+        return Err(err("expected 32-byte hex"));
+    }
+    out.copy_from_slice(&v);
+    Ok(out)
+}
+fn hexs(b: &[u8]) -> String {
+    b.iter()
+        .fold(String::with_capacity(b.len() * 2), |mut out, byte| {
+            write!(&mut out, "{byte:02x}").expect("writing to String is infallible");
+            out
+        })
+}
+fn receipt_from_json(v: &serde_json::Value) -> Result<SubmissionV3, Box<dyn Error>> {
+    import_receipt(&serde_json::to_string(v)?)
+        .ok_or_else(|| err("unsupported or malformed Receipt v3 JSON"))
+}
+
+fn ids_bytes(ids: &[u32]) -> Vec<u8> {
+    let mut bytes = Vec::with_capacity(ids.len() * 8);
+    for &id in ids {
+        bytes.extend_from_slice(&u64::from(id).to_le_bytes());
+    }
+    bytes
+}
+
+fn prompt_bound_fields(prompt_ids: &[u32], n_predict: u32) -> (Hash64, Hash64, Hash64) {
+    let network_id = domain_hash64("qi35-network/v3", SCHEMA, &[NETWORK_LABEL]);
+    let prompt_commitment = domain_hash64(
+        "qi35-prompt/v3",
+        SCHEMA,
+        &[&network_id, &ids_bytes(prompt_ids)],
+    );
+    let job_challenge = domain_hash64(
+        "qi35-self-challenge/v3",
+        SCHEMA,
+        &[&network_id, &prompt_commitment, &n_predict.to_le_bytes()],
+    );
+    let schedule_root = domain_hash64(
+        "qi35-schedule/v3",
+        SCHEMA,
+        &[
+            RULESET_ID.as_bytes(),
+            &(prompt_ids.len() as u64).to_le_bytes(),
+            &u64::from(n_predict).to_le_bytes(),
+            &u64::from(EOS_TOKEN).to_le_bytes(),
+        ],
+    );
+    (network_id, job_challenge, schedule_root)
+}
+
+fn compute_set_id(model_hash: &[u8; 32], tables_hash: &[u8; 32]) -> Hash64 {
+    domain_hash64(
+        "qi35-compute-set/v3",
+        SCHEMA,
+        &[model_hash, tables_hash, RULESET_ID.as_bytes()],
+    )
+}
+
+struct Cli {
+    receipt: PathBuf,
+    bundle: Option<PathBuf>,
+    audit_key_file: Option<PathBuf>,
+    state_db: Option<PathBuf>,
+    rerun: bool,
+    engine: Option<PathBuf>,
+    tables: Option<PathBuf>,
+    threads: u32,
+    pair: Option<PathBuf>,
+    model_override: Option<PathBuf>,
+}
+
+fn parse_cli() -> Result<Cli, Box<dyn Error>> {
+    let mut cli = Cli {
+        receipt: PathBuf::new(),
+        bundle: None,
+        audit_key_file: None,
+        state_db: None,
+        rerun: false,
+        engine: std::env::var("QI35_ENGINE").ok().map(PathBuf::from),
+        tables: std::env::var("QI35_TABLES").ok().map(PathBuf::from),
+        threads: 8,
+        pair: None,
+        model_override: None,
+    };
+    let mut receipt = None;
+    let mut arguments = std::env::args().skip(1);
+    while let Some(argument) = arguments.next() {
+        let mut val = |name: &str| -> Result<String, Box<dyn Error>> {
+            arguments
+                .next()
+                .ok_or_else(|| err(format!("{name} requires a value")))
+        };
+        match argument.as_str() {
+            "--receipt" => receipt = Some(PathBuf::from(val("--receipt")?)),
+            "--bundle" => cli.bundle = Some(PathBuf::from(val("--bundle")?)),
+            "--audit-key-file" => {
+                cli.audit_key_file = Some(PathBuf::from(val("--audit-key-file")?));
+            }
+            "--state-db" => cli.state_db = Some(PathBuf::from(val("--state-db")?)),
+            "--rerun" => cli.rerun = true,
+            "--engine" => cli.engine = Some(PathBuf::from(val("--engine")?)),
+            "--tables" => cli.tables = Some(PathBuf::from(val("--tables")?)),
+            "--threads" => cli.threads = val("--threads")?.parse()?,
+            "--pair" => cli.pair = Some(PathBuf::from(val("--pair")?)),
+            "--model" => cli.model_override = Some(PathBuf::from(val("--model")?)),
+            "--help" | "-h" => {
+                println!(
+                    "usage: palw-verify-integer --receipt FILE.json [--bundle FILE.bundle \
+                     --audit-key-file KEY] [--state-db FILE] [--rerun --engine E --tables T] \
+                     [--pair OTHER.json]"
+                );
+                std::process::exit(0);
+            }
+            _ => return Err(err("unknown command-line argument")),
+        }
+    }
+    cli.receipt = receipt.ok_or_else(|| err("--receipt is required"))?;
+    Ok(cli)
+}
+
+#[allow(clippy::too_many_lines)]
+fn run() -> Result<(), Box<dyn Error>> {
+    let workspace = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .ok_or_else(|| err("runtime crate has no workspace parent"))?;
+    let cli = parse_cli()?;
+    let json: serde_json::Value = serde_json::from_slice(&std::fs::read(&cli.receipt)?)?;
+    let SubmissionV3 {
+        receipt,
+        envelope,
+        verifying_key: vk,
+    } = receipt_from_json(&json)?;
+    let mut checks: Vec<(&str, bool)> = Vec::new();
+
+    // 1. ML-DSA-87 signature over the reconstructed body. This is an offline artifact check, not
+    // selected-chain admission; admission additionally requires ReceiptV3Expectations.
+    let sig_ok = verify_receipt_v3_self_consistent(&receipt, &envelope, &vk).is_ok();
+    checks.push(("ml_dsa_signature", sig_ok));
+    // 2. receipt_id consistency
+    let rid = receipt.receipt_id();
+    let receipt_id_ok = match json.get("receipt_id").and_then(serde_json::Value::as_str) {
+        Some(declared) => hexs(&rid) == declared,
+        None => true,
+    };
+    checks.push(("receipt_id", receipt_id_ok));
+    // credential binding: envelope signer == body credential == hash(vk)
+    let vk_credential = credential_id_from_verifying_key(&vk);
+    checks.push((
+        "credential_binding",
+        envelope.signer_credential_id == receipt.worker_credential_id
+            && vk_credential == receipt.worker_credential_id,
+    ));
+
+    // The flat canonical-integer layout carries artifact declarations. Re-derive the signed
+    // compute-set id and bind the engine declaration to signed telemetry. The portable nested
+    // layout deliberately contains only the canonical receipt/envelope/key tuple.
+    if json.get("schema").and_then(serde_json::Value::as_str)
+        == Some("palw.integer-receipt/v3-envelope")
+    {
+        let artifact = |name: &str| -> Result<[u8; 32], Box<dyn Error>> {
+            let value = json
+                .pointer(&format!("/artifacts/{name}"))
+                .and_then(serde_json::Value::as_str)
+                .ok_or_else(|| err(format!("missing artifact {name}")))?;
+            unhex32(value)
+        };
+        let ruleset = json
+            .pointer("/artifacts/ruleset_id")
+            .and_then(serde_json::Value::as_str)
+            .ok_or_else(|| err("missing artifact ruleset_id"))?;
+        let model_hash = artifact("model_blake2b256")?;
+        let tables_hash = artifact("tables_blake2b256")?;
+        let engine_hash = artifact("engine_blake2b256")?;
+        checks.push(("ruleset_id", ruleset == RULESET_ID));
+        checks.push((
+            "compute_set_id(artifacts)",
+            compute_set_id(&model_hash, &tables_hash) == receipt.projection.compute_set_id,
+        ));
+        checks.push((
+            "runtime_manifest_hash(engine)",
+            engine_hash == receipt.telemetry.runtime_manifest_hash,
+        ));
+    }
+
+    // 3-4. bundle opening + commitment recomputation
+    let mut opening_ids: Option<(Vec<u32>, Vec<u32>, u32, u32)> = None;
+    if let (Some(bundle_path), Some(key_path)) = (&cli.bundle, &cli.audit_key_file) {
+        let audit_key = std::fs::read(key_path)?;
+        let bundle = std::fs::read(bundle_path)?;
+        if bundle.len() < 8 + 64 + 24 || &bundle[..8] != b"QI35BND1" {
+            return Err(err("bundle header invalid"));
+        }
+        let rid_b = &bundle[8..72];
+        checks.push(("bundle_receipt_binding", rid_b == rid.as_slice()));
+        let nonce = XNonce::from_slice(&bundle[72..96]);
+        let key64 = domain_hash64("qi35-bundle-key/v1", SCHEMA, &[&audit_key, &rid]);
+        let cipher = XChaCha20Poly1305::new_from_slice(&key64[..32]).map_err(|_| err("key"))?;
+        let plain = cipher
+            .decrypt(
+                nonce,
+                Payload {
+                    msg: &bundle[96..],
+                    aad: &rid,
+                },
+            )
+            .map_err(|_| err("bundle decryption failed (wrong audit key or tampered)"))?;
+        let opening: serde_json::Value = serde_json::from_slice(&plain)?;
+        let get_ids = |k: &str| -> Result<Vec<u64>, Box<dyn Error>> {
+            opening
+                .get(k)
+                .and_then(serde_json::Value::as_array)
+                .ok_or_else(|| err(format!("opening missing {k}")))?
+                .iter()
+                .map(|x| x.as_u64().ok_or_else(|| err("bad id")))
+                .collect()
+        };
+        let prompt_ids = get_ids("prompt_ids")?;
+        let output_ids = get_ids("output_ids")?;
+        let n_predict = u32::try_from(
+            opening
+                .get("n_predict")
+                .and_then(serde_json::Value::as_u64)
+                .ok_or_else(|| err("opening missing n_predict"))?,
+        )?;
+        if !(1..=1024).contains(&n_predict) {
+            return Err(err("opening n_predict is outside 1..=1024"));
+        }
+        let issued_threads = u32::try_from(
+            opening
+                .get("threads")
+                .and_then(serde_json::Value::as_u64)
+                .ok_or_else(|| err("opening missing threads"))?,
+        )?;
+        checks.push(("opening_threads", issued_threads > 0));
+        let route_d = unhex32(
+            opening["engine_route_digest"]
+                .as_str()
+                .ok_or_else(|| err("route digest"))?,
+        )?;
+        let kv_d = unhex32(
+            opening["engine_kv_digest"]
+                .as_str()
+                .ok_or_else(|| err("kv digest"))?,
+        )?;
+        let state_d = unhex32(
+            opening["engine_state_digest"]
+                .as_str()
+                .ok_or_else(|| err("state digest"))?,
+        )?;
+
+        let prompt_tokens: Vec<u32> = prompt_ids
+            .iter()
+            .copied()
+            .map(|id| u32::try_from(id).map_err(|_| err("prompt token id exceeds u32")))
+            .collect::<Result<_, _>>()?;
+        let output_tokens: Vec<u32> = output_ids
+            .iter()
+            .copied()
+            .map(|id| u32::try_from(id).map_err(|_| err("output token id exceeds u32")))
+            .collect::<Result<_, _>>()?;
+        let (network_id, job_challenge, schedule_root) =
+            prompt_bound_fields(&prompt_tokens, n_predict);
+        checks.push(("network_id", network_id == receipt.network_id));
+        checks.push((
+            "job_challenge(prompt)",
+            job_challenge == receipt.projection.job_challenge,
+        ));
+        checks.push((
+            "schedule_root(prompt,n_predict)",
+            schedule_root == receipt.projection.schedule_root,
+        ));
+        let output_commitment =
+            output_commitment_v3(&output_tokens, &receipt.projection.job_challenge);
+        checks.push((
+            "output_commitment(opening)",
+            output_commitment == receipt.projection.output_commitment,
+        ));
+        checks.push((
+            "route_root(opening)",
+            domain_hash64("qi35-exec-route/v3", SCHEMA, &[&route_d])
+                == receipt.projection.route_root,
+        ));
+        checks.push((
+            "execution_root(opening)",
+            domain_hash64("qi35-exec-kv/v3", SCHEMA, &[&kv_d]) == receipt.projection.execution_root,
+        ));
+        checks.push((
+            "state_root(opening)",
+            domain_hash64("qi35-exec-state/v3", SCHEMA, &[&state_d])
+                == receipt.projection.state_root,
+        ));
+        let prefill = u32::try_from(prompt_ids.len())?;
+        let generated = u32::try_from(output_ids.len())?;
+        checks.push((
+            "token_count",
+            receipt.projection.token_count == u64::from(prefill) + u64::from(generated),
+        ));
+        checks.push((
+            "canonical_compute_units",
+            receipt.projection.canonical_compute_units
+                == qwen36_semantic_compute_units(prefill, generated),
+        ));
+        opening_ids = Some((prompt_tokens, output_tokens, n_predict, issued_threads));
+    }
+
+    // 5. state-db row
+    if let Some(db) = &cli.state_db {
+        let conn = rusqlite::Connection::open(db)?;
+        let row: Result<String, _> = conn.query_row(
+            "SELECT public_json FROM integer_receipts WHERE receipt_id = ?1",
+            [hexs(&rid)],
+            |r| r.get(0),
+        );
+        match row {
+            Ok(stored) => {
+                let stored_v: serde_json::Value = serde_json::from_str(&stored)?;
+                checks.push(("state_db_row", stored_v == json));
+            }
+            Err(_) => checks.push(("state_db_row", false)),
+        }
+    }
+
+    // 6. independent engine re-run (the cross-backend reproduction check)
+    if cli.rerun {
+        let (prompt_ids, output_ids, n_predict, _issued_threads) = opening_ids
+            .as_ref()
+            .ok_or_else(|| err("--rerun requires --bundle and --audit-key-file"))?;
+        let engine = cli
+            .engine
+            .as_ref()
+            .ok_or_else(|| err("--rerun requires --engine"))?;
+        let tables = cli
+            .tables
+            .as_ref()
+            .ok_or_else(|| err("--rerun requires --tables"))?;
+        let model = cli.model_override.clone().unwrap_or_else(|| {
+            workspace.join(
+                "models/Qwen3.6-abliterated-35b-Claude-4.7/Qwen3.6-abliterated-35b-Claude-4.7-Q4_K_M.gguf",
+            )
+        });
+        let ids_csv = prompt_ids
+            .iter()
+            .map(u32::to_string)
+            .collect::<Vec<_>>()
+            .join(",");
+        let extra = std::env::var("QI35_ENGINE_ARGS").unwrap_or_default();
+        let out = Command::new(engine)
+            .arg(&model)
+            .arg(tables)
+            .args(["--ids", &ids_csv])
+            .args(["--max-new", &n_predict.to_string()])
+            .args(["--eos", &EOS_TOKEN.to_string()])
+            .args(["--threads", &cli.threads.to_string()])
+            .args(extra.split_whitespace())
+            .output()?;
+        let stdout = String::from_utf8_lossy(&out.stdout).into_owned();
+        let mut rerun_ids: Vec<u32> = Vec::new();
+        let mut roots = std::collections::HashMap::new();
+        for line in stdout.lines() {
+            if let Some(rest) = line.strip_prefix("generated = ") {
+                rerun_ids = rest
+                    .trim()
+                    .trim_start_matches('[')
+                    .trim_end_matches(']')
+                    .split(',')
+                    .map(str::trim)
+                    .filter(|s| !s.is_empty())
+                    .map(|s| s.parse().unwrap_or(u32::MAX))
+                    .collect();
+            }
+            for key in ["route_root", "kv_root", "state_root"] {
+                if let Some(rest) = line.strip_prefix(&format!("{key} = ")) {
+                    roots.insert(key, rest.trim().to_owned());
+                }
+            }
+        }
+        checks.push(("rerun_output_ids", &rerun_ids == output_ids));
+        checks.push((
+            "rerun_route_root",
+            roots.get("route_root").is_some_and(|h| {
+                domain_hash64(
+                    "qi35-exec-route/v3",
+                    SCHEMA,
+                    &[&unhex32(h).unwrap_or_default()],
+                ) == receipt.projection.route_root
+            }),
+        ));
+        checks.push((
+            "rerun_kv_root",
+            roots.get("kv_root").is_some_and(|h| {
+                domain_hash64(
+                    "qi35-exec-kv/v3",
+                    SCHEMA,
+                    &[&unhex32(h).unwrap_or_default()],
+                ) == receipt.projection.execution_root
+            }),
+        ));
+        checks.push((
+            "rerun_state_root",
+            roots.get("state_root").is_some_and(|h| {
+                domain_hash64(
+                    "qi35-exec-state/v3",
+                    SCHEMA,
+                    &[&unhex32(h).unwrap_or_default()],
+                ) == receipt.projection.state_root
+            }),
+        ));
+    }
+
+    // 7. k=2 pair (cross-vendor)
+    if let Some(pair_path) = &cli.pair {
+        let other_json: serde_json::Value = serde_json::from_slice(&std::fs::read(pair_path)?)?;
+        let SubmissionV3 {
+            receipt: other,
+            envelope: other_env,
+            verifying_key: other_vk,
+        } = receipt_from_json(&other_json)?;
+        let pair_sig_ok = verify_receipt_v3_self_consistent(&other, &other_env, &other_vk).is_ok();
+        checks.push(("pair_ml_dsa_signature", pair_sig_ok));
+        if sig_ok && pair_sig_ok {
+            match match_pair_v3(&receipt, &other) {
+                Ok(pair) => {
+                    checks.push(("k2_pair_match", true));
+                    println!("local_pair_id(non_admission)={}", hexs(&pair.pair_id));
+                }
+                Err(e) => {
+                    checks.push(("k2_pair_match", false));
+                    println!("pair_error={e:?}");
+                }
+            }
+        } else {
+            checks.push(("k2_pair_match", false));
+            println!("pair_error=signature verification failed before low-level matching");
+        }
+    }
+
+    println!("receipt_id={}", hexs(&rid));
+    println!("class=canonical_integer_v0 signature=ml-dsa-87");
+    println!("scope=offline-self-consistency non_admission=true");
+    let mut all = true;
+    for (name, ok) in &checks {
+        println!("  [{}] {}", if *ok { "PASS" } else { "FAIL" }, name);
+        all = all && *ok;
+    }
+    println!(
+        "VERIFY_OFFLINE_NON_ADMISSION: {}",
+        if all { "PASS" } else { "FAIL" }
+    );
+    if all {
+        Ok(())
+    } else {
+        Err(err("verification failed"))
+    }
+}
+
+fn main() {
+    if let Err(error) = run() {
+        eprintln!("palw-verify-integer: {error}");
+        std::process::exit(1);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn prompt_and_n_predict_are_bound_to_signed_fields() {
+        let (_, challenge, schedule) = prompt_bound_fields(&[11, 22, 33], 8);
+        let (_, changed_prompt, same_schedule) = prompt_bound_fields(&[11, 99, 33], 8);
+        let (_, changed_n_predict, changed_schedule) = prompt_bound_fields(&[11, 22, 33], 9);
+        assert_ne!(challenge, changed_prompt, "same-length prompt substitution");
+        assert_eq!(
+            schedule, same_schedule,
+            "schedule binds prompt length, not contents"
+        );
+        assert_ne!(challenge, changed_n_predict, "challenge binds n_predict");
+        assert_ne!(schedule, changed_schedule, "schedule binds n_predict");
+    }
+
+    #[test]
+    fn artifact_drift_changes_compute_set() {
+        let original = compute_set_id(&[1; 32], &[2; 32]);
+        assert_ne!(original, compute_set_id(&[3; 32], &[2; 32]));
+        assert_ne!(original, compute_set_id(&[1; 32], &[4; 32]));
+    }
+}
diff --git a/runtime-palw/src/bin/palw-worker.rs b/runtime-palw/src/bin/palw-worker.rs
new file mode 100644
index 0000000000000000000000000000000000000000..42616567cc159662c1e7a0bbe277906fa177ce20
--- /dev/null
+++ b/runtime-palw/src/bin/palw-worker.rs
@@ -0,0 +1,371 @@
+//! palw-worker — T-shared testnet worker CLI with startup mode selection.
+//!
+//! On startup the worker chooses (interactively on a TTY, or via `--mode`) between:
+//! - **自家発注ジョブ (`self-job`)** — originator: mint a fresh shared `JobSpecV2` (slot 0), run the
+//!   job result through v3 issuance, store + export the submission AND the spec (handed to a verifier).
+//! - **検証 (`verify`)** — verifier: consume a distributed spec (slot forced to 1) + the originator's
+//!   submission, issue own receipt from own recomputation, then verify both ML-DSA envelopes and run
+//!   the local low-level k=2 predicate. This CLI verdict is explicitly non-admission; selected-chain
+//!   admission additionally requires node-supplied `ReceiptV3Expectations` and registry state.
+//!
+//! The compute result (token ids + canonical roots) comes from the integer-canonical runner as a JSON
+//! file — this binary owns the PALW protocol side, not the model execution.
+
+use runtime_palw::receipt_v3::mldsa::{
+    verify_receipt_v3_self_consistent, verifying_key_and_credential_from_seed,
+};
+use runtime_palw::receipt_v3::{match_pair_v3, Hash64, ImplementationTelemetry};
+use runtime_palw::testnet::flow::issue_receipt_v3;
+use runtime_palw::testnet::{
+    export_job_spec, export_receipt, import_job_spec, import_receipt, store_receipt, JobSpecV2,
+    WorkerResultV1,
+};
+use std::io::{BufRead, IsTerminal, Write};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Mode {
+    SelfJob,
+    Verify,
+}
+
+struct Cli {
+    mode: Option<Mode>,
+    spec: Option<String>,
+    result: String,
+    peer: Option<String>,
+    seed_file: String,
+    store: String,
+    network: String,
+}
+
+fn usage_with_exit_code(exit_code: i32) -> ! {
+    eprintln!(
+        "usage: palw-worker [--mode self-job|verify] --result FILE --seed-file FILE \\\n\
+         \x20                  [--spec FILE] [--peer FILE] [--store DIR] [--network LABEL]\n\
+         \n\
+         mode selection (起動時選択):\n\
+         \x20 --mode self-job   自家発注ジョブ: mint a fresh job spec (slot 0), issue + export\n\
+         \x20 --mode verify     検証: consume --spec + --peer, recompute, issue (slot 1), k=2 match\n\
+         \x20 (omit --mode on a TTY to choose interactively)\n\
+         \n\
+         \x20 --result FILE     worker result JSON from the integer-canonical runner\n\
+         \x20 --seed-file FILE  32-byte ML-DSA signing seed (worker credential)\n\
+         \x20 --spec FILE       job spec JSON (required for verify; optional for self-job)\n\
+         \x20 --peer FILE       originator submission JSON (verify mode)\n\
+         \x20 --store DIR       receipt store directory (default: ./palw-testnet-store)\n\
+         \x20 --network LABEL   network label for self-ordered specs (default: t-shared-testnet)"
+    );
+    std::process::exit(exit_code);
+}
+
+fn usage() -> ! {
+    usage_with_exit_code(2)
+}
+
+fn parse_cli() -> Cli {
+    let mut cli = Cli {
+        mode: None,
+        spec: None,
+        result: String::new(),
+        peer: None,
+        seed_file: String::new(),
+        store: "palw-testnet-store".to_string(),
+        network: "t-shared-testnet".to_string(),
+    };
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    let mut i = 0;
+    while i < args.len() {
+        let need = |i: usize| -> &str { args.get(i + 1).unwrap_or_else(|| usage()) };
+        match args[i].as_str() {
+            "--mode" => {
+                cli.mode = Some(match need(i) {
+                    "self-job" => Mode::SelfJob,
+                    "verify" => Mode::Verify,
+                    _ => usage(),
+                });
+                i += 2;
+            }
+            "--spec" => {
+                cli.spec = Some(need(i).to_string());
+                i += 2;
+            }
+            "--result" => {
+                cli.result = need(i).to_string();
+                i += 2;
+            }
+            "--peer" => {
+                cli.peer = Some(need(i).to_string());
+                i += 2;
+            }
+            "--seed-file" => {
+                cli.seed_file = need(i).to_string();
+                i += 2;
+            }
+            "--store" => {
+                cli.store = need(i).to_string();
+                i += 2;
+            }
+            "--network" => {
+                cli.network = need(i).to_string();
+                i += 2;
+            }
+            "--help" | "-h" => usage_with_exit_code(0),
+            _ => usage(),
+        }
+    }
+    if cli.result.is_empty() || cli.seed_file.is_empty() {
+        usage();
+    }
+    cli
+}
+
+/// Interactive startup selection (only reached on a TTY with no `--mode`).
+fn choose_mode_interactively() -> Mode {
+    let stdin = std::io::stdin();
+    loop {
+        eprintln!("起動モードを選択してください:");
+        eprintln!("  [1] 自家発注ジョブ (self-job) — 新しい job spec を発行して実行結果に署名");
+        eprintln!(
+            "  [2] 検証 (verify)             — 配布 spec + 相手の submission を検証し k=2 照合"
+        );
+        eprint!("> ");
+        std::io::stderr().flush().ok();
+        let mut line = String::new();
+        if stdin.lock().read_line(&mut line).unwrap_or(0) == 0 {
+            eprintln!("stdin closed — aborting");
+            std::process::exit(2);
+        }
+        match line.trim() {
+            "1" | "self-job" => return Mode::SelfJob,
+            "2" | "verify" => return Mode::Verify,
+            _ => eprintln!("1 か 2 を入力してください"),
+        }
+    }
+}
+
+fn read_file(path: &str) -> String {
+    std::fs::read_to_string(path).unwrap_or_else(|e| {
+        eprintln!("cannot read {path}: {e}");
+        std::process::exit(2);
+    })
+}
+
+fn parse_hex64(s: &str) -> Option<Hash64> {
+    if s.len() != 128 || !s.bytes().all(|c| c.is_ascii_hexdigit()) {
+        return None;
+    }
+    let mut out = [0u8; 64];
+    for (i, byte) in out.iter_mut().enumerate() {
+        *byte = u8::from_str_radix(&s[2 * i..2 * i + 2], 16).ok()?;
+    }
+    Some(out)
+}
+
+/// Parse the worker-result JSON emitted by the integer-canonical runner.
+fn parse_result(json: &str) -> Option<(WorkerResultV1, Option<u32>)> {
+    let root: serde_json::Value = serde_json::from_str(json).ok()?;
+    let tokens: Vec<u32> = root
+        .get("tokens")?
+        .as_array()?
+        .iter()
+        .map(|value| u32::try_from(value.as_u64()?).ok())
+        .collect::<Option<_>>()?;
+    let gh = |k: &str| -> Option<Hash64> { parse_hex64(root.get(k)?.as_str()?) };
+    let zero = [0u8; 64];
+    let tele = root.get("telemetry");
+    let gt = |k: &str| -> [u8; 32] {
+        tele.and_then(|t| t.get(k))
+            .and_then(|v| v.as_str())
+            .and_then(|s| {
+                let v = (0..s.len() / 2)
+                    .map(|i| u8::from_str_radix(&s[2 * i..2 * i + 2], 16).ok())
+                    .collect::<Option<Vec<u8>>>()?;
+                v.try_into().ok()
+            })
+            .unwrap_or([0u8; 32])
+    };
+    let prompt_token_count = match root.get("prompt_token_count") {
+        Some(value) => Some(u32::try_from(value.as_u64()?).ok()?),
+        None => None,
+    };
+    Some((
+        WorkerResultV1 {
+            tokens,
+            schedule_root: gh("schedule_root")?,
+            execution_root: gh("execution_root")?,
+            route_root: gh("route_root").unwrap_or(zero),
+            state_root: gh("state_root").unwrap_or(zero),
+            canonical_compute_units: root.get("canonical_compute_units")?.as_u64()?,
+            stop_reason: u8::try_from(
+                root.get("stop_reason")
+                    .and_then(serde_json::Value::as_u64)
+                    .unwrap_or(0),
+            )
+            .ok()?,
+            telemetry: ImplementationTelemetry {
+                runtime_class_id: gt("runtime_class_id"),
+                runtime_manifest_hash: gt("runtime_manifest_hash"),
+            },
+        },
+        prompt_token_count,
+    ))
+}
+
+fn load_seed(path: &str) -> ([u8; 32], Hash64) {
+    let bytes = std::fs::read(path).unwrap_or_else(|e| {
+        eprintln!("cannot read seed file {path}: {e}");
+        std::process::exit(2);
+    });
+    let seed: [u8; 32] = bytes.as_slice().try_into().unwrap_or_else(|_| {
+        eprintln!("seed file must be exactly 32 bytes (got {})", bytes.len());
+        std::process::exit(2);
+    });
+    // Receipt v3 makes the signing key and registered worker credential the same identity.
+    let credential = verifying_key_and_credential_from_seed(&seed).1;
+    (seed, credential)
+}
+
+fn os_entropy64() -> Hash64 {
+    let mut out = [0u8; 64];
+    getrandom::getrandom(&mut out).expect("OS entropy");
+    out
+}
+
+#[allow(clippy::too_many_lines)]
+fn main() {
+    let cli = parse_cli();
+    let mode = cli.mode.unwrap_or_else(|| {
+        if std::io::stdin().is_terminal() {
+            choose_mode_interactively()
+        } else {
+            eprintln!("--mode is required when stdin is not a TTY (self-job|verify)");
+            std::process::exit(2);
+        }
+    });
+    let (seed, credential) = load_seed(&cli.seed_file);
+    let (result, result_prompt_token_count) =
+        parse_result(&read_file(&cli.result)).unwrap_or_else(|| {
+            eprintln!("malformed result JSON: {}", cli.result);
+            std::process::exit(2);
+        });
+    let store_dir = std::path::PathBuf::from(&cli.store);
+
+    match mode {
+        Mode::SelfJob => {
+            // 自家発注: originator mints the spec (slot 0) unless one was supplied.
+            let spec = match &cli.spec {
+                Some(path) => import_job_spec(&read_file(path)).unwrap_or_else(|| {
+                    eprintln!("malformed job spec: {path}");
+                    std::process::exit(2);
+                }),
+                None => JobSpecV2 {
+                    network_id: runtime_palw::receipt_v3::domain_hash64(
+                        "testnet-network-id/v1",
+                        3,
+                        &[cli.network.as_bytes()],
+                    ),
+                    // Cross-vendor canonical-INTEGER calibration compute-set (the tractable
+                    // Qwen2.5-0.5B model used to prove bit-identical integer determinism across
+                    // vendors). This is deliberately NOT the Qwen3.6-35B-A3B main runtime model;
+                    // the 35B float path is too large to reproduce bit-identically across vendors,
+                    // so the k=2 cross-vendor demo runs on this retained calibration set. The
+                    // string is a compute_set_id hash input — do not change it without reissuing.
+                    compute_set_id: runtime_palw::receipt_v3::domain_hash64(
+                        "testnet-compute-set/v1",
+                        3,
+                        &[b"qwen2.5-0.5b-canonical-int".as_slice()],
+                    ),
+                    job_challenge: os_entropy64(),
+                    replica_slot: 0,
+                    prompt_token_count: result_prompt_token_count.unwrap_or_else(|| {
+                        eprintln!(
+                            "self-job without --spec requires prompt_token_count in --result JSON"
+                        );
+                        std::process::exit(2);
+                    }),
+                    issued_epoch: 1,
+                    expires_epoch: 1000,
+                },
+            };
+            if result_prompt_token_count.is_some_and(|count| count != spec.prompt_token_count) {
+                eprintln!("result prompt_token_count does not match the job spec");
+                std::process::exit(2);
+            }
+            let sub = issue_receipt_v3(&spec, &result, credential, &seed).unwrap_or_else(|e| {
+                eprintln!("issue failed: {e:?}");
+                std::process::exit(1);
+            });
+            let path = store_receipt(&store_dir, &sub).expect("store receipt");
+            // hand-off spec for the verifier (slot flipped to 1)
+            let mut vspec = spec;
+            vspec.replica_slot = 1;
+            let spec_path = store_dir.join("jobspec.for-verifier.json");
+            std::fs::write(&spec_path, export_job_spec(&vspec)).expect("write spec");
+            println!("mode          = self-job (自家発注ジョブ)");
+            println!("submission    = {}", path.display());
+            println!("verifier spec = {}", spec_path.display());
+        }
+        Mode::Verify => {
+            let spec_path = cli.spec.unwrap_or_else(|| {
+                eprintln!("verify mode requires --spec");
+                std::process::exit(2);
+            });
+            let peer_path = cli.peer.unwrap_or_else(|| {
+                eprintln!("verify mode requires --peer (originator submission)");
+                std::process::exit(2);
+            });
+            let mut spec = import_job_spec(&read_file(&spec_path)).unwrap_or_else(|| {
+                eprintln!("malformed job spec: {spec_path}");
+                std::process::exit(2);
+            });
+            spec.replica_slot = 1; // verifier is always the second replica
+            if result_prompt_token_count.is_some_and(|count| count != spec.prompt_token_count) {
+                eprintln!("result prompt_token_count does not match the job spec");
+                std::process::exit(2);
+            }
+            let peer = import_receipt(&read_file(&peer_path)).unwrap_or_else(|| {
+                eprintln!("malformed peer submission: {peer_path}");
+                std::process::exit(2);
+            });
+            let mine = issue_receipt_v3(&spec, &result, credential, &seed).unwrap_or_else(|e| {
+                eprintln!("issue failed: {e:?}");
+                std::process::exit(1);
+            });
+            store_receipt(&store_dir, &mine).expect("store receipt");
+            println!("mode          = verify (検証)");
+            let peer_signature_ok = verify_receipt_v3_self_consistent(
+                &peer.receipt,
+                &peer.envelope,
+                &peer.verifying_key,
+            )
+            .is_ok();
+            let mine_signature_ok = verify_receipt_v3_self_consistent(
+                &mine.receipt,
+                &mine.envelope,
+                &mine.verifying_key,
+            )
+            .is_ok();
+            if !peer_signature_ok || !mine_signature_ok {
+                println!("local k2 verdict = REJECTED (signature verification failed)");
+                std::process::exit(1);
+            }
+            match match_pair_v3(&peer.receipt, &mine.receipt) {
+                Ok(pair) => {
+                    let hex: String = pair.pair_id.iter().fold(String::new(), |mut acc, b| {
+                        use std::fmt::Write as _;
+                        let _ = write!(acc, "{b:02x}");
+                        acc
+                    });
+                    println!("local k2      = MATCHED (NON-ADMISSION)");
+                    println!("pair_id       = {hex}");
+                }
+                Err(e) => {
+                    println!("local k2      = REJECTED ({e:?}; NON-ADMISSION)");
+                    // export own submission anyway so the divergence can be audited
+                    let _ = export_receipt(&mine);
+                    std::process::exit(1);
+                }
+            }
+        }
+    }
+}
diff --git a/runtime-palw/src/lib.rs b/runtime-palw/src/lib.rs
index 8287c22cd2bd57dc36d4f7cbd212b367322debab..2d0250838e89a29a2612cce57641df76671a4d29 100644
--- a/runtime-palw/src/lib.rs
+++ b/runtime-palw/src/lib.rs
@@ -23,6 +23,7 @@ pub mod external;
 pub mod external_authority;
 pub mod future_beacon;
 pub mod job;
+pub mod lifecycle;
 pub mod manifest;
 pub mod matcher;
 pub mod mint;
diff --git a/runtime-palw/src/lifecycle.rs b/runtime-palw/src/lifecycle.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d5fde4cbe4db2a62d9eb38c0eed41dcb1a2d1c95
--- /dev/null
+++ b/runtime-palw/src/lifecycle.rs
@@ -0,0 +1,4670 @@
+//! Durable, signed lifecycle orchestration for externally funded Receipt-v3 work.
+//!
+//! This module is an operational control plane, not consensus. It deliberately uses a dedicated
+//! `SQLite` schema: the mature [`crate::state_store`] schema stores the legacy 32-byte receipt
+//! protocol, while node-owned Receipt v3 uses 64-byte identities. Mixing those identity spaces in
+//! one set of foreign keys would make both replay protection and migration ambiguous.
+//!
+//! Every state-changing input is a strictly decoded, versioned Ed25519 envelope. Authority keys are
+//! network/epoch/permission scoped, every target has a monotonic sequence, and an exact replay is
+//! accepted only while the target remains at the event's recorded post-state. Preparation creates
+//! a stable payment command; only a separately signed terminal confirmation marks money settled or
+//! refunded. Signing keys are never accepted or persisted by this API.
+
+#![allow(
+    clippy::items_after_statements,
+    clippy::too_many_arguments,
+    clippy::too_many_lines,
+    clippy::type_complexity
+)]
+
+use crate::commitment::{
+    CanonicalDeserialize, CanonicalReader, CanonicalSerialize, CanonicalWriter, DecodeError, Hash32,
+};
+use crate::receipt::signer_key_id;
+use crate::receipt_v3::MLDSA87_SIGNATURE_LEN;
+use crate::receipt_v3::{Hash64, MLDSA87_VERIFYING_KEY_LEN};
+use crate::testnet::SubmissionV3;
+#[cfg(feature = "ml-dsa")]
+use crate::testnet::{export_receipt, import_receipt};
+use blake2b_simd::Params as Blake2bParams;
+use ed25519_dalek::{Signature, VerifyingKey};
+use rusqlite::{params, Connection, OptionalExtension, Transaction, TransactionBehavior};
+use sha3::{Digest, Sha3_256};
+use std::path::Path;
+use thiserror::Error;
+
+/// Lifecycle event/body schema version.
+pub const LIFECYCLE_EVENT_VERSION_V1: u16 = 1;
+/// Lifecycle target-state schema version.
+pub const LIFECYCLE_STATE_VERSION_V1: u16 = 1;
+/// Signed lifecycle envelope version.
+pub const LIFECYCLE_ENVELOPE_VERSION_V1: u16 = 1;
+/// Bridge artifact schema version.
+pub const LIFECYCLE_BRIDGE_VERSION_V1: u16 = 1;
+/// Node-compatible outer `PalwReceiptDaObjectV2` bridge artifact.
+pub const LIFECYCLE_BRIDGE_VERSION_V2: u16 = 2;
+
+const ED25519_ALGORITHM_ID: u8 = 0;
+const APPLICATION_ID: i32 = 0x5041_4c43; // "PALC"
+const SCHEMA_VERSION: i32 = 1;
+const MAX_EVENT_BODY_BYTES: usize = 256 * 1024;
+#[cfg(feature = "ml-dsa")]
+const MAX_SUBMISSION_BYTES: usize = 64 * 1024;
+const DA_CHUNK_BYTES: usize = 16 * 1024;
+const DA_MAX_OBJECT_BYTES: usize = 256 * 1024;
+
+const EVENT_SIGNING_DOMAIN: &[u8] = b"misaka-palw-lifecycle-event-signing-v1";
+const EVENT_ID_DOMAIN: &[u8] = b"misaka-palw-lifecycle-event-id-v1";
+const SUBMISSION_DOMAIN: &[u8] = b"misaka-palw-lifecycle-submission-v1";
+const PAYMENT_COMMAND_DOMAIN: &[u8] = b"misaka-palw-lifecycle-payment-command-v1";
+const BRIDGE_OBJECT_DOMAIN: &[u8] = b"misaka-palw-lifecycle-v3-bridge-object-v1";
+const DA_CHUNK_LEAF_DOMAIN: &[u8] = b"misaka-palw-da-chunk-leaf-v1";
+const DA_CHUNK_EMPTY_DOMAIN: &[u8] = b"misaka-palw-da-chunk-empty-v1";
+const DA_CHUNK_NODE_DOMAIN: &[u8] = b"misaka-palw-da-chunk-node-v1";
+const DA_OBJECT_ROOT_DOMAIN: &[u8] = b"misaka-palw-da-object-root-v1";
+
+const SCHEMA_SQL: &str = r"
+CREATE TABLE IF NOT EXISTS lifecycle_meta (
+    key TEXT PRIMARY KEY,
+    value BLOB NOT NULL
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_authorities (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    authority_key_id BLOB NOT NULL CHECK(length(authority_key_id) = 32),
+    verifying_key BLOB NOT NULL CHECK(length(verifying_key) = 32),
+    valid_from_epoch BLOB NOT NULL CHECK(length(valid_from_epoch) = 8),
+    valid_through_epoch BLOB NOT NULL CHECK(length(valid_through_epoch) = 8),
+    revoked_at_epoch BLOB CHECK(revoked_at_epoch IS NULL OR length(revoked_at_epoch) = 8),
+    permissions INTEGER NOT NULL CHECK(permissions > 0 AND permissions < 64),
+    PRIMARY KEY(network_id, authority_key_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_escrows (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    escrow_id BLOB NOT NULL CHECK(length(escrow_id) = 64),
+    state_version INTEGER NOT NULL CHECK(state_version = 1),
+    state INTEGER NOT NULL CHECK(state BETWEEN 1 AND 9),
+    sequence BLOB NOT NULL CHECK(length(sequence) = 8),
+    requester_id BLOB NOT NULL CHECK(length(requester_id) = 64),
+    asset_id BLOB NOT NULL CHECK(length(asset_id) = 64),
+    total_amount BLOB NOT NULL CHECK(length(total_amount) = 8),
+    funded_epoch BLOB NOT NULL CHECK(length(funded_epoch) = 8),
+    expires_epoch BLOB NOT NULL CHECK(length(expires_epoch) = 8),
+    funding_reference BLOB NOT NULL CHECK(length(funding_reference) = 64),
+    job_nullifier BLOB CHECK(job_nullifier IS NULL OR length(job_nullifier) = 64),
+    compute_set_id BLOB CHECK(compute_set_id IS NULL OR length(compute_set_id) = 64),
+    job_challenge BLOB CHECK(job_challenge IS NULL OR length(job_challenge) = 64),
+    issued_epoch BLOB CHECK(issued_epoch IS NULL OR length(issued_epoch) = 8),
+    assigned_expires_epoch BLOB CHECK(assigned_expires_epoch IS NULL OR length(assigned_expires_epoch) = 8),
+    worker_0 BLOB CHECK(worker_0 IS NULL OR length(worker_0) = 64),
+    worker_1 BLOB CHECK(worker_1 IS NULL OR length(worker_1) = 64),
+    bond_amount BLOB CHECK(bond_amount IS NULL OR length(bond_amount) = 8),
+    fraud_window_end BLOB CHECK(fraud_window_end IS NULL OR length(fraud_window_end) = 8),
+    receipt_0 BLOB CHECK(receipt_0 IS NULL OR length(receipt_0) = 64),
+    receipt_1 BLOB CHECK(receipt_1 IS NULL OR length(receipt_1) = 64),
+    pair_id BLOB CHECK(pair_id IS NULL OR length(pair_id) = 64),
+    payment_command_id BLOB CHECK(payment_command_id IS NULL OR length(payment_command_id) = 64),
+    terminal_confirmation_id BLOB CHECK(terminal_confirmation_id IS NULL OR length(terminal_confirmation_id) = 64),
+    PRIMARY KEY(network_id, escrow_id),
+    UNIQUE(network_id, funding_reference),
+    UNIQUE(network_id, job_nullifier),
+    UNIQUE(network_id, pair_id),
+    UNIQUE(network_id, payment_command_id),
+    UNIQUE(network_id, terminal_confirmation_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_bonds (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    worker_credential_id BLOB NOT NULL CHECK(length(worker_credential_id) = 64),
+    asset_id BLOB NOT NULL CHECK(length(asset_id) = 64),
+    total_amount BLOB NOT NULL CHECK(length(total_amount) = 8),
+    locked_amount BLOB NOT NULL CHECK(length(locked_amount) = 8),
+    hold_until_epoch BLOB NOT NULL CHECK(length(hold_until_epoch) = 8),
+    sequence BLOB NOT NULL CHECK(length(sequence) = 8),
+    PRIMARY KEY(network_id, worker_credential_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_bond_funding (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    funding_reference BLOB NOT NULL CHECK(length(funding_reference) = 64),
+    worker_credential_id BLOB NOT NULL CHECK(length(worker_credential_id) = 64),
+    canonical_event BLOB NOT NULL,
+    PRIMARY KEY(network_id, funding_reference),
+    FOREIGN KEY(network_id, worker_credential_id)
+        REFERENCES lifecycle_bonds(network_id, worker_credential_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_assignments (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    escrow_id BLOB NOT NULL CHECK(length(escrow_id) = 64),
+    replica_slot INTEGER NOT NULL CHECK(replica_slot IN (0, 1)),
+    worker_credential_id BLOB NOT NULL CHECK(length(worker_credential_id) = 64),
+    locked_amount BLOB NOT NULL CHECK(length(locked_amount) = 8),
+    status INTEGER NOT NULL CHECK(status IN (1, 2, 3)),
+    fraud_window_end BLOB NOT NULL CHECK(length(fraud_window_end) = 8),
+    PRIMARY KEY(network_id, escrow_id, replica_slot),
+    UNIQUE(network_id, escrow_id, worker_credential_id),
+    FOREIGN KEY(network_id, escrow_id)
+        REFERENCES lifecycle_escrows(network_id, escrow_id),
+    FOREIGN KEY(network_id, worker_credential_id)
+        REFERENCES lifecycle_bonds(network_id, worker_credential_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_receipts (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    receipt_id BLOB NOT NULL CHECK(length(receipt_id) = 64),
+    execution_nullifier BLOB NOT NULL CHECK(length(execution_nullifier) = 64),
+    job_nullifier BLOB NOT NULL CHECK(length(job_nullifier) = 64),
+    escrow_id BLOB NOT NULL CHECK(length(escrow_id) = 64),
+    replica_slot INTEGER NOT NULL CHECK(replica_slot IN (0, 1)),
+    canonical_body BLOB NOT NULL,
+    canonical_envelope BLOB NOT NULL,
+    verifying_key BLOB NOT NULL CHECK(length(verifying_key) = 2592),
+    canonical_submission_json BLOB NOT NULL,
+    admission_event_id BLOB NOT NULL CHECK(length(admission_event_id) = 64),
+    PRIMARY KEY(network_id, receipt_id),
+    UNIQUE(network_id, execution_nullifier),
+    UNIQUE(network_id, job_nullifier, replica_slot),
+    UNIQUE(network_id, escrow_id, replica_slot),
+    FOREIGN KEY(network_id, escrow_id)
+        REFERENCES lifecycle_escrows(network_id, escrow_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_pairs (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    pair_id BLOB NOT NULL CHECK(length(pair_id) = 64),
+    escrow_id BLOB NOT NULL CHECK(length(escrow_id) = 64),
+    job_nullifier BLOB NOT NULL CHECK(length(job_nullifier) = 64),
+    ready_epoch BLOB NOT NULL CHECK(length(ready_epoch) = 8),
+    PRIMARY KEY(network_id, pair_id),
+    UNIQUE(network_id, escrow_id),
+    UNIQUE(network_id, job_nullifier),
+    FOREIGN KEY(network_id, escrow_id)
+        REFERENCES lifecycle_escrows(network_id, escrow_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_payment_commands (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    command_id BLOB NOT NULL CHECK(length(command_id) = 64),
+    escrow_id BLOB NOT NULL CHECK(length(escrow_id) = 64),
+    terminal_kind INTEGER NOT NULL CHECK(terminal_kind IN (1, 2)),
+    worker_amount BLOB NOT NULL CHECK(length(worker_amount) = 8),
+    protocol_amount BLOB NOT NULL CHECK(length(protocol_amount) = 8),
+    requester_amount BLOB NOT NULL CHECK(length(requester_amount) = 8),
+    prepared_epoch BLOB NOT NULL CHECK(length(prepared_epoch) = 8),
+    prepared_event_id BLOB NOT NULL CHECK(length(prepared_event_id) = 64),
+    confirmation_id BLOB CHECK(confirmation_id IS NULL OR length(confirmation_id) = 64),
+    PRIMARY KEY(network_id, command_id),
+    UNIQUE(network_id, escrow_id),
+    UNIQUE(network_id, confirmation_id),
+    FOREIGN KEY(network_id, escrow_id)
+        REFERENCES lifecycle_escrows(network_id, escrow_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_slashes (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    slash_id BLOB NOT NULL CHECK(length(slash_id) = 64),
+    escrow_id BLOB NOT NULL CHECK(length(escrow_id) = 64),
+    worker_credential_id BLOB NOT NULL CHECK(length(worker_credential_id) = 64),
+    amount BLOB NOT NULL CHECK(length(amount) = 8),
+    canonical_event BLOB NOT NULL,
+    PRIMARY KEY(network_id, slash_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_unbonds (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    confirmation_id BLOB NOT NULL CHECK(length(confirmation_id) = 64),
+    worker_credential_id BLOB NOT NULL CHECK(length(worker_credential_id) = 64),
+    amount BLOB NOT NULL CHECK(length(amount) = 8),
+    canonical_event BLOB NOT NULL,
+    PRIMARY KEY(network_id, confirmation_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_external_references (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    reference_id BLOB NOT NULL CHECK(length(reference_id) = 64),
+    reference_kind INTEGER NOT NULL CHECK(reference_kind BETWEEN 1 AND 6),
+    event_id BLOB NOT NULL CHECK(length(event_id) = 64),
+    PRIMARY KEY(network_id, reference_id)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS lifecycle_events (
+    network_id BLOB NOT NULL CHECK(length(network_id) = 64),
+    event_id BLOB NOT NULL CHECK(length(event_id) = 64),
+    authority_key_id BLOB NOT NULL CHECK(length(authority_key_id) = 32),
+    event_nonce BLOB NOT NULL CHECK(length(event_nonce) = 64),
+    target_id BLOB NOT NULL CHECK(length(target_id) = 64),
+    target_kind INTEGER NOT NULL CHECK(target_kind IN (1, 2)),
+    event_kind INTEGER NOT NULL CHECK(event_kind BETWEEN 1 AND 11),
+    canonical_event BLOB NOT NULL,
+    post_sequence BLOB NOT NULL CHECK(length(post_sequence) = 8),
+    post_state INTEGER NOT NULL,
+    PRIMARY KEY(network_id, event_id),
+    UNIQUE(network_id, authority_key_id, event_nonce)
+) WITHOUT ROWID;
+";
+
+/// Capabilities assigned to one lifecycle authority.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct LifecyclePermissions(u8);
+
+impl LifecyclePermissions {
+    /// Funding-finality attestations.
+    pub const FUNDING: u8 = 1;
+    /// Escrow locking, assignment, and terminal preparation.
+    pub const LIFECYCLE: u8 = 2;
+    /// Receipt admission after worker-signature verification.
+    pub const ADMISSION: u8 = 4;
+    /// Settlement/refund rail confirmations.
+    pub const TERMINAL: u8 = 8;
+    /// Bond funding and externally confirmed unbonding.
+    pub const BOND: u8 = 16;
+    /// Final slash decisions.
+    pub const SLASH: u8 = 32;
+
+    /// Creates a checked permission mask.
+    pub fn new(bits: u8) -> Result<Self, LifecycleError> {
+        if bits == 0 || bits & !0x3f != 0 {
+            return Err(LifecycleError::InvalidAuthority);
+        }
+        Ok(Self(bits))
+    }
+
+    /// All currently defined permissions.
+    #[must_use]
+    pub const fn all() -> Self {
+        Self(0x3f)
+    }
+
+    /// Raw persisted permission bits.
+    #[must_use]
+    pub const fn bits(self) -> u8 {
+        self.0
+    }
+
+    const fn contains(self, permission: u8) -> bool {
+        self.0 & permission != 0
+    }
+}
+
+/// Out-of-band trust-root record. Registering this record is a local governance operation; it is
+/// intentionally not an implicit self-signed event.
+#[derive(Debug, Clone)]
+pub struct LifecycleAuthorityRecord {
+    /// Network/genesis namespace.
+    pub network_id: Hash64,
+    /// Ed25519 public verifying key.
+    pub verifying_key: VerifyingKey,
+    /// First authorized event epoch, inclusive.
+    pub valid_from_epoch: u64,
+    /// Last authorized event epoch, inclusive.
+    pub valid_through_epoch: u64,
+    /// Revocation epoch, inclusive.
+    pub revoked_at_epoch: Option<u64>,
+    /// Explicit capabilities.
+    pub permissions: LifecyclePermissions,
+}
+
+/// A typed lifecycle mutation.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum LifecycleEventPayloadV1 {
+    /// Finalized external funding creates an escrow.
+    FundingConfirmed {
+        /// Escrow identity.
+        escrow_id: Hash64,
+        /// Requester identity.
+        requester_id: Hash64,
+        /// Asset identity.
+        asset_id: Hash64,
+        /// Exact funded amount.
+        amount: u64,
+        /// Last epoch before timeout preparation is allowed.
+        expires_epoch: u64,
+        /// External payment/funding event identity.
+        funding_reference: Hash64,
+    },
+    /// Reserving already-finalized escrow value.
+    EscrowLocked {
+        /// Escrow identity.
+        escrow_id: Hash64,
+        /// Must equal the funded amount.
+        amount: u64,
+    },
+    /// Finalized bond funding.
+    BondFunded {
+        /// Worker/provider credential.
+        worker_credential_id: Hash64,
+        /// Asset identity.
+        asset_id: Hash64,
+        /// Credited amount.
+        amount: u64,
+        /// External funding event identity.
+        funding_reference: Hash64,
+    },
+    /// Assigns two independent workers and atomically locks both bonds.
+    Assigned {
+        /// Escrow identity.
+        escrow_id: Hash64,
+        /// Job-wide nullifier, unique inside this network.
+        job_nullifier: Hash64,
+        /// Registered compute set.
+        compute_set_id: Hash64,
+        /// Node/scheduler-issued challenge.
+        job_challenge: Hash64,
+        /// Receipt issue epoch.
+        issued_epoch: u64,
+        /// Receipt expiry epoch.
+        expires_epoch: u64,
+        /// Slot-zero credential.
+        worker_0: Hash64,
+        /// Slot-one credential.
+        worker_1: Hash64,
+        /// Amount locked from each worker.
+        bond_amount: u64,
+        /// Settlement/unbond remain blocked through this epoch.
+        fraud_window_end: u64,
+    },
+    /// Admits one independently authenticated Receipt-v3 submission.
+    ReceiptAdmitted {
+        /// Escrow identity.
+        escrow_id: Hash64,
+        /// Receipt identity derived from its canonical body.
+        receipt_id: Hash64,
+        /// Assigned replica slot.
+        replica_slot: u8,
+        /// Commitment to the exact canonical submission material.
+        submission_commitment: Hash64,
+    },
+    /// Prepares, but does not confirm, a settlement payment command.
+    SettlementPrepared {
+        /// Escrow identity.
+        escrow_id: Hash64,
+        /// Total paid to workers by the external rail.
+        worker_amount: u64,
+        /// Protocol amount.
+        protocol_amount: u64,
+        /// Requester return/reserve amount.
+        requester_amount: u64,
+    },
+    /// Confirms an already-prepared settlement using terminal-authority evidence.
+    SettlementConfirmed {
+        /// Escrow identity.
+        escrow_id: Hash64,
+        /// Exact prepared command.
+        command_id: Hash64,
+        /// External rail finality identity.
+        rail_confirmation_id: Hash64,
+    },
+    /// Prepares a full refund after the escrow/assignment timeout.
+    TimeoutRefundPrepared {
+        /// Escrow identity.
+        escrow_id: Hash64,
+        /// Must equal the entire funded amount.
+        requester_amount: u64,
+    },
+    /// Confirms a prepared refund using terminal-authority evidence.
+    RefundConfirmed {
+        /// Escrow identity.
+        escrow_id: Hash64,
+        /// Exact prepared command.
+        command_id: Hash64,
+        /// External rail finality identity.
+        rail_confirmation_id: Hash64,
+    },
+    /// Final bond-authority slash decision; an active escrow becomes refund-prepared.
+    SlashFinalized {
+        /// Escrow identity.
+        escrow_id: Hash64,
+        /// Faulting assigned worker.
+        worker_credential_id: Hash64,
+        /// Globally stable slash evidence/decision identity within the network.
+        slash_id: Hash64,
+        /// Must equal that assignment's complete locked amount.
+        amount: u64,
+        /// Worker unbonding remains blocked through this epoch.
+        hold_until_epoch: u64,
+    },
+    /// External authority confirms bond withdrawal after all gates close.
+    UnbondConfirmed {
+        /// Worker credential.
+        worker_credential_id: Hash64,
+        /// Asset identity.
+        asset_id: Hash64,
+        /// Withdrawn amount.
+        amount: u64,
+        /// External rail finality identity.
+        rail_confirmation_id: Hash64,
+    },
+}
+
+/// Versioned body signed by an authorized control-plane key.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LifecycleEventBodyV1 {
+    /// Event schema version.
+    pub version: u16,
+    /// Target-state schema version.
+    pub state_version: u16,
+    /// Network/genesis namespace.
+    pub network_id: Hash64,
+    /// Evidence/decision epoch.
+    pub epoch: u64,
+    /// Exact next target sequence.
+    pub sequence: u64,
+    /// Non-zero authority-generated replay nonce.
+    pub nonce: Hash64,
+    /// Typed mutation.
+    pub payload: LifecycleEventPayloadV1,
+}
+
+/// Canonical signed event. It contains public verification material only.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SignedLifecycleEventV1 {
+    /// Envelope schema version.
+    pub envelope_version: u16,
+    /// SHA3-256 identity of the registered Ed25519 key.
+    pub authority_key_id: Hash32,
+    /// Only algorithm 0 (Ed25519) is accepted by this v1 envelope.
+    pub algorithm: u8,
+    /// Typed body.
+    pub body: LifecycleEventBodyV1,
+    /// Ed25519 signature over [`LifecycleEventBodyV1::signing_digest`].
+    pub signature: [u8; 64],
+}
+
+/// Durable escrow state.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum LifecycleEscrowState {
+    /// Funding authority confirmed value.
+    Funded = 1,
+    /// Value is reserved for work.
+    Locked = 2,
+    /// Two workers and their bonds are assigned.
+    Assigned = 3,
+    /// Exactly one receipt is admitted.
+    ReceiptOne = 4,
+    /// Two authenticated receipts matched.
+    EvidenceReady = 5,
+    /// Settlement command exists; no settlement is claimed yet.
+    SettlementPrepared = 6,
+    /// Terminal authority confirmed settlement finality.
+    Settled = 7,
+    /// Refund command exists; no refund is claimed yet.
+    RefundPrepared = 8,
+    /// Terminal authority confirmed refund finality.
+    Refunded = 9,
+}
+
+/// Result of applying a signed event.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct LifecycleApplyOutcome {
+    /// Stable ID of the exact signed envelope.
+    pub event_id: Hash64,
+    /// False only for an exact replay while target state has not advanced.
+    pub newly_applied: bool,
+    /// Target sequence after the event.
+    pub sequence: u64,
+    /// Escrow-state tag, or zero for bond-account events.
+    pub state: u8,
+    /// Stable prepared payment command, when this event produced one.
+    pub payment_command_id: Option<Hash64>,
+}
+
+/// Read-only operational escrow snapshot.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LifecycleEscrowStatus {
+    /// Network namespace.
+    pub network_id: Hash64,
+    /// Escrow identity.
+    pub escrow_id: Hash64,
+    /// Durable state.
+    pub state: LifecycleEscrowState,
+    /// Last applied target sequence.
+    pub sequence: u64,
+    /// Exact funded total.
+    pub total_amount: u64,
+    /// Assigned job nullifier, when any.
+    pub job_nullifier: Option<Hash64>,
+    /// Matched pair identity, when ready.
+    pub pair_id: Option<Hash64>,
+    /// Prepared external command, when any.
+    pub payment_command_id: Option<Hash64>,
+    /// Signed external finality identity, only after terminal confirmation.
+    pub terminal_confirmation_id: Option<Hash64>,
+}
+
+/// DA-01 chunk-tree commitment computed over the explicitly non-node-object bridge payload.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct LifecycleBridgeDaCommitmentV1 {
+    /// DA object algorithm version (currently 1).
+    pub object_version: u16,
+    /// Exact bridge payload length.
+    pub object_len: u32,
+    /// Fixed 16-KiB chunk count.
+    pub chunk_count: u16,
+    /// DA-01-compatible chunk-tree root.
+    pub root: Hash64,
+}
+
+/// One DA-01-compatible proof over the lifecycle bridge payload.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LifecycleBridgeDaProofV1 {
+    /// Chunk index.
+    pub chunk_index: u16,
+    /// Exact chunk bytes.
+    pub chunk: Vec<u8>,
+    /// Bottom-up Merkle siblings.
+    pub siblings: Vec<Hash64>,
+}
+
+/// Operational lifecycle failures. All ambiguous/replayed/conflicting cases fail closed.
+#[derive(Debug, Error)]
+pub enum LifecycleError {
+    /// `SQLite` failure.
+    #[error("lifecycle SQLite error: {0}")]
+    Sqlite(#[from] rusqlite::Error),
+    /// Strict canonical decoding failure.
+    #[error("invalid canonical lifecycle event: {0}")]
+    Decode(#[from] DecodeError),
+    /// Store belongs to another application/schema.
+    #[error("lifecycle store schema/application mismatch")]
+    SchemaMismatch,
+    /// A stored value violated the schema contract.
+    #[error("corrupt lifecycle store value: {0}")]
+    Corrupt(&'static str),
+    /// Authority bootstrap record is malformed or conflicts.
+    #[error("invalid or conflicting lifecycle authority")]
+    InvalidAuthority,
+    /// Event key was not registered for this network.
+    #[error("unknown lifecycle authority")]
+    UnknownAuthority,
+    /// Key is outside its validity interval or revoked.
+    #[error("lifecycle authority is not active at the event epoch")]
+    AuthorityInactive,
+    /// Key lacks the event-specific capability.
+    #[error("lifecycle authority permission denied")]
+    AuthorityPermission,
+    /// Ed25519 signature failed strict verification.
+    #[error("invalid lifecycle authority signature")]
+    InvalidSignature,
+    /// Body, payload, version, target, amount, or epoch is malformed.
+    #[error("invalid lifecycle event structure")]
+    InvalidEvent,
+    /// Sequence is not the exact next target sequence.
+    #[error("lifecycle target sequence conflict")]
+    SequenceConflict,
+    /// Same event ID or nonce was reused for different bytes.
+    #[error("conflicting lifecycle event replay")]
+    ReplayConflict,
+    /// An old event was replayed after its target advanced.
+    #[error("exact lifecycle replay after target state advanced")]
+    ReplayAfterAdvance,
+    /// Target does not exist.
+    #[error("lifecycle target not found")]
+    NotFound,
+    /// State transition is not allowed.
+    #[error("lifecycle state transition conflict")]
+    StateConflict,
+    /// Network/job/worker/receipt/payment binding differs.
+    #[error("lifecycle event binding mismatch")]
+    BindingMismatch,
+    /// Addition/subtraction exceeded the exact amount domain.
+    #[error("lifecycle amount overflow or underflow")]
+    Amount,
+    /// Bond is absent, insufficient, locked, slashed, or still on hold.
+    #[error("bond gate rejected lifecycle transition")]
+    BondGate,
+    /// Fraud window has not closed.
+    #[error("fraud window is still open")]
+    FraudWindowOpen,
+    /// Receipt input is absent or unexpectedly supplied.
+    #[error("receipt submission input mismatch")]
+    ReceiptInput,
+    /// Portable receipt parsing or cryptographic verification failed.
+    #[error("Receipt-v3 admission failed: {0}")]
+    ReceiptVerification(String),
+    /// The two authenticated receipts failed k=2 matching.
+    #[error("Receipt-v3 pair mismatch: {0}")]
+    ReceiptMismatch(String),
+    /// A network-scoped job/execution nullifier was already consumed.
+    #[error("network-scoped nullifier already consumed")]
+    NullifierConsumed,
+    /// A payment/bond/terminal/slash external identity was already consumed by any event kind.
+    #[error("network-scoped external reference already consumed")]
+    ExternalReferenceConsumed,
+    /// Payment command or signed terminal evidence differs.
+    #[error("terminal confirmation does not bind the prepared command")]
+    TerminalBinding,
+    /// Bridge object exceeds the current DA bound.
+    #[error("lifecycle bridge object is too large")]
+    BridgeTooLarge,
+    /// External selected-chain context cannot produce the exact node Object-v2 schema.
+    #[error("invalid PALW node DA Object-v2 context: {0}")]
+    InvalidNodeDaContext(&'static str),
+}
+
+fn keyed_hash(domain: &[u8], bytes: &[u8]) -> Hash64 {
+    let mut out = [0_u8; 64];
+    out.copy_from_slice(
+        Blake2bParams::new()
+            .hash_length(64)
+            .key(domain)
+            .to_state()
+            .update(bytes)
+            .finalize()
+            .as_bytes(),
+    );
+    out
+}
+
+fn nonzero64(value: &Hash64) -> bool {
+    value.iter().any(|byte| *byte != 0)
+}
+
+fn write_hash64(writer: &mut CanonicalWriter, value: &Hash64) {
+    writer.write_bytes(value);
+}
+
+fn read_hash64(reader: &mut CanonicalReader<'_>) -> Result<Hash64, DecodeError> {
+    reader
+        .read_bytes_with_limit(64)?
+        .try_into()
+        .map_err(|_| DecodeError::InvalidField("expected 64-byte lifecycle identity"))
+}
+
+fn put_u64(value: u64) -> [u8; 8] {
+    value.to_be_bytes()
+}
+
+fn get_u64(bytes: Vec<u8>, field: &'static str) -> Result<u64, LifecycleError> {
+    let bytes: [u8; 8] = bytes
+        .try_into()
+        .map_err(|_| LifecycleError::Corrupt(field))?;
+    Ok(u64::from_be_bytes(bytes))
+}
+
+fn get_hash64(bytes: Vec<u8>, field: &'static str) -> Result<Hash64, LifecycleError> {
+    bytes.try_into().map_err(|_| LifecycleError::Corrupt(field))
+}
+
+fn to_hex(bytes: &[u8]) -> String {
+    use std::fmt::Write as _;
+    bytes
+        .iter()
+        .fold(String::with_capacity(bytes.len() * 2), |mut out, byte| {
+            let _ = write!(out, "{byte:02x}");
+            out
+        })
+}
+
+fn from_hex(value: &str) -> Option<Vec<u8>> {
+    if value.len() % 2 != 0 || !value.bytes().all(|byte| byte.is_ascii_hexdigit()) {
+        return None;
+    }
+    (0..value.len() / 2)
+        .map(|index| u8::from_str_radix(&value[2 * index..2 * index + 2], 16).ok())
+        .collect()
+}
+
+impl LifecycleEventPayloadV1 {
+    fn tag(&self) -> u8 {
+        match self {
+            Self::FundingConfirmed { .. } => 1,
+            Self::EscrowLocked { .. } => 2,
+            Self::BondFunded { .. } => 3,
+            Self::Assigned { .. } => 4,
+            Self::ReceiptAdmitted { .. } => 5,
+            Self::SettlementPrepared { .. } => 6,
+            Self::SettlementConfirmed { .. } => 7,
+            Self::TimeoutRefundPrepared { .. } => 8,
+            Self::RefundConfirmed { .. } => 9,
+            Self::SlashFinalized { .. } => 10,
+            Self::UnbondConfirmed { .. } => 11,
+        }
+    }
+
+    fn permission(&self) -> u8 {
+        match self {
+            Self::FundingConfirmed { .. } => LifecyclePermissions::FUNDING,
+            Self::EscrowLocked { .. }
+            | Self::Assigned { .. }
+            | Self::SettlementPrepared { .. }
+            | Self::TimeoutRefundPrepared { .. } => LifecyclePermissions::LIFECYCLE,
+            Self::ReceiptAdmitted { .. } => LifecyclePermissions::ADMISSION,
+            Self::SettlementConfirmed { .. } | Self::RefundConfirmed { .. } => {
+                LifecyclePermissions::TERMINAL
+            }
+            Self::BondFunded { .. } | Self::UnbondConfirmed { .. } => LifecyclePermissions::BOND,
+            Self::SlashFinalized { .. } => LifecyclePermissions::SLASH,
+        }
+    }
+
+    fn target(&self) -> (u8, Hash64) {
+        match self {
+            Self::BondFunded {
+                worker_credential_id,
+                ..
+            }
+            | Self::UnbondConfirmed {
+                worker_credential_id,
+                ..
+            } => (2, *worker_credential_id),
+            Self::FundingConfirmed { escrow_id, .. }
+            | Self::EscrowLocked { escrow_id, .. }
+            | Self::Assigned { escrow_id, .. }
+            | Self::ReceiptAdmitted { escrow_id, .. }
+            | Self::SettlementPrepared { escrow_id, .. }
+            | Self::SettlementConfirmed { escrow_id, .. }
+            | Self::TimeoutRefundPrepared { escrow_id, .. }
+            | Self::RefundConfirmed { escrow_id, .. }
+            | Self::SlashFinalized { escrow_id, .. } => (1, *escrow_id),
+        }
+    }
+
+    fn validate(&self) -> Result<(), LifecycleError> {
+        let (_, target) = self.target();
+        if !nonzero64(&target) {
+            return Err(LifecycleError::InvalidEvent);
+        }
+        match self {
+            Self::FundingConfirmed {
+                requester_id,
+                asset_id,
+                amount,
+                funding_reference,
+                ..
+            } => {
+                if !nonzero64(requester_id)
+                    || !nonzero64(asset_id)
+                    || !nonzero64(funding_reference)
+                    || *amount == 0
+                {
+                    return Err(LifecycleError::InvalidEvent);
+                }
+            }
+            Self::EscrowLocked { amount, .. } => {
+                if *amount == 0 {
+                    return Err(LifecycleError::InvalidEvent);
+                }
+            }
+            Self::BondFunded {
+                asset_id,
+                amount,
+                funding_reference,
+                ..
+            } => {
+                if !nonzero64(asset_id) || !nonzero64(funding_reference) || *amount == 0 {
+                    return Err(LifecycleError::InvalidEvent);
+                }
+            }
+            Self::Assigned {
+                job_nullifier,
+                compute_set_id,
+                job_challenge,
+                issued_epoch,
+                expires_epoch,
+                worker_0,
+                worker_1,
+                bond_amount,
+                fraud_window_end,
+                ..
+            } => {
+                if [
+                    job_nullifier,
+                    compute_set_id,
+                    job_challenge,
+                    worker_0,
+                    worker_1,
+                ]
+                .into_iter()
+                .any(|value| !nonzero64(value))
+                    || worker_0 == worker_1
+                    || issued_epoch > expires_epoch
+                    || fraud_window_end < expires_epoch
+                    || *bond_amount == 0
+                {
+                    return Err(LifecycleError::InvalidEvent);
+                }
+            }
+            Self::ReceiptAdmitted {
+                receipt_id,
+                replica_slot,
+                submission_commitment,
+                ..
+            } => {
+                if !nonzero64(receipt_id) || !nonzero64(submission_commitment) || *replica_slot > 1
+                {
+                    return Err(LifecycleError::InvalidEvent);
+                }
+            }
+            Self::SettlementPrepared {
+                worker_amount,
+                protocol_amount,
+                requester_amount,
+                ..
+            } => {
+                if worker_amount
+                    .checked_add(*protocol_amount)
+                    .and_then(|sum| sum.checked_add(*requester_amount))
+                    .is_none()
+                {
+                    return Err(LifecycleError::Amount);
+                }
+            }
+            Self::SettlementConfirmed {
+                command_id,
+                rail_confirmation_id,
+                ..
+            }
+            | Self::RefundConfirmed {
+                command_id,
+                rail_confirmation_id,
+                ..
+            } => {
+                if !nonzero64(command_id) || !nonzero64(rail_confirmation_id) {
+                    return Err(LifecycleError::InvalidEvent);
+                }
+            }
+            Self::TimeoutRefundPrepared {
+                requester_amount, ..
+            } => {
+                if *requester_amount == 0 {
+                    return Err(LifecycleError::InvalidEvent);
+                }
+            }
+            Self::SlashFinalized {
+                worker_credential_id,
+                slash_id,
+                amount,
+                ..
+            } => {
+                if !nonzero64(worker_credential_id) || !nonzero64(slash_id) || *amount == 0 {
+                    return Err(LifecycleError::InvalidEvent);
+                }
+            }
+            Self::UnbondConfirmed {
+                asset_id,
+                amount,
+                rail_confirmation_id,
+                ..
+            } => {
+                if !nonzero64(asset_id) || !nonzero64(rail_confirmation_id) || *amount == 0 {
+                    return Err(LifecycleError::InvalidEvent);
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+impl CanonicalSerialize for LifecycleEventPayloadV1 {
+    fn encode_canonical(&self, writer: &mut CanonicalWriter) {
+        writer.write_u8(self.tag());
+        match self {
+            Self::FundingConfirmed {
+                escrow_id,
+                requester_id,
+                asset_id,
+                amount,
+                expires_epoch,
+                funding_reference,
+            } => {
+                for value in [escrow_id, requester_id, asset_id] {
+                    write_hash64(writer, value);
+                }
+                writer.write_u64(*amount);
+                writer.write_u64(*expires_epoch);
+                write_hash64(writer, funding_reference);
+            }
+            Self::EscrowLocked { escrow_id, amount } => {
+                write_hash64(writer, escrow_id);
+                writer.write_u64(*amount);
+            }
+            Self::BondFunded {
+                worker_credential_id,
+                asset_id,
+                amount,
+                funding_reference,
+            } => {
+                write_hash64(writer, worker_credential_id);
+                write_hash64(writer, asset_id);
+                writer.write_u64(*amount);
+                write_hash64(writer, funding_reference);
+            }
+            Self::Assigned {
+                escrow_id,
+                job_nullifier,
+                compute_set_id,
+                job_challenge,
+                issued_epoch,
+                expires_epoch,
+                worker_0,
+                worker_1,
+                bond_amount,
+                fraud_window_end,
+            } => {
+                for value in [escrow_id, job_nullifier, compute_set_id, job_challenge] {
+                    write_hash64(writer, value);
+                }
+                writer.write_u64(*issued_epoch);
+                writer.write_u64(*expires_epoch);
+                write_hash64(writer, worker_0);
+                write_hash64(writer, worker_1);
+                writer.write_u64(*bond_amount);
+                writer.write_u64(*fraud_window_end);
+            }
+            Self::ReceiptAdmitted {
+                escrow_id,
+                receipt_id,
+                replica_slot,
+                submission_commitment,
+            } => {
+                write_hash64(writer, escrow_id);
+                write_hash64(writer, receipt_id);
+                writer.write_u8(*replica_slot);
+                write_hash64(writer, submission_commitment);
+            }
+            Self::SettlementPrepared {
+                escrow_id,
+                worker_amount,
+                protocol_amount,
+                requester_amount,
+            } => {
+                write_hash64(writer, escrow_id);
+                writer.write_u64(*worker_amount);
+                writer.write_u64(*protocol_amount);
+                writer.write_u64(*requester_amount);
+            }
+            Self::SettlementConfirmed {
+                escrow_id,
+                command_id,
+                rail_confirmation_id,
+            }
+            | Self::RefundConfirmed {
+                escrow_id,
+                command_id,
+                rail_confirmation_id,
+            } => {
+                write_hash64(writer, escrow_id);
+                write_hash64(writer, command_id);
+                write_hash64(writer, rail_confirmation_id);
+            }
+            Self::TimeoutRefundPrepared {
+                escrow_id,
+                requester_amount,
+            } => {
+                write_hash64(writer, escrow_id);
+                writer.write_u64(*requester_amount);
+            }
+            Self::SlashFinalized {
+                escrow_id,
+                worker_credential_id,
+                slash_id,
+                amount,
+                hold_until_epoch,
+            } => {
+                write_hash64(writer, escrow_id);
+                write_hash64(writer, worker_credential_id);
+                write_hash64(writer, slash_id);
+                writer.write_u64(*amount);
+                writer.write_u64(*hold_until_epoch);
+            }
+            Self::UnbondConfirmed {
+                worker_credential_id,
+                asset_id,
+                amount,
+                rail_confirmation_id,
+            } => {
+                write_hash64(writer, worker_credential_id);
+                write_hash64(writer, asset_id);
+                writer.write_u64(*amount);
+                write_hash64(writer, rail_confirmation_id);
+            }
+        }
+    }
+}
+
+impl CanonicalDeserialize for LifecycleEventPayloadV1 {
+    fn decode_canonical(reader: &mut CanonicalReader<'_>) -> Result<Self, DecodeError> {
+        let payload = match reader.read_u8()? {
+            1 => Self::FundingConfirmed {
+                escrow_id: read_hash64(reader)?,
+                requester_id: read_hash64(reader)?,
+                asset_id: read_hash64(reader)?,
+                amount: reader.read_u64()?,
+                expires_epoch: reader.read_u64()?,
+                funding_reference: read_hash64(reader)?,
+            },
+            2 => Self::EscrowLocked {
+                escrow_id: read_hash64(reader)?,
+                amount: reader.read_u64()?,
+            },
+            3 => Self::BondFunded {
+                worker_credential_id: read_hash64(reader)?,
+                asset_id: read_hash64(reader)?,
+                amount: reader.read_u64()?,
+                funding_reference: read_hash64(reader)?,
+            },
+            4 => Self::Assigned {
+                escrow_id: read_hash64(reader)?,
+                job_nullifier: read_hash64(reader)?,
+                compute_set_id: read_hash64(reader)?,
+                job_challenge: read_hash64(reader)?,
+                issued_epoch: reader.read_u64()?,
+                expires_epoch: reader.read_u64()?,
+                worker_0: read_hash64(reader)?,
+                worker_1: read_hash64(reader)?,
+                bond_amount: reader.read_u64()?,
+                fraud_window_end: reader.read_u64()?,
+            },
+            5 => Self::ReceiptAdmitted {
+                escrow_id: read_hash64(reader)?,
+                receipt_id: read_hash64(reader)?,
+                replica_slot: reader.read_u8()?,
+                submission_commitment: read_hash64(reader)?,
+            },
+            6 => Self::SettlementPrepared {
+                escrow_id: read_hash64(reader)?,
+                worker_amount: reader.read_u64()?,
+                protocol_amount: reader.read_u64()?,
+                requester_amount: reader.read_u64()?,
+            },
+            7 => Self::SettlementConfirmed {
+                escrow_id: read_hash64(reader)?,
+                command_id: read_hash64(reader)?,
+                rail_confirmation_id: read_hash64(reader)?,
+            },
+            8 => Self::TimeoutRefundPrepared {
+                escrow_id: read_hash64(reader)?,
+                requester_amount: reader.read_u64()?,
+            },
+            9 => Self::RefundConfirmed {
+                escrow_id: read_hash64(reader)?,
+                command_id: read_hash64(reader)?,
+                rail_confirmation_id: read_hash64(reader)?,
+            },
+            10 => Self::SlashFinalized {
+                escrow_id: read_hash64(reader)?,
+                worker_credential_id: read_hash64(reader)?,
+                slash_id: read_hash64(reader)?,
+                amount: reader.read_u64()?,
+                hold_until_epoch: reader.read_u64()?,
+            },
+            11 => Self::UnbondConfirmed {
+                worker_credential_id: read_hash64(reader)?,
+                asset_id: read_hash64(reader)?,
+                amount: reader.read_u64()?,
+                rail_confirmation_id: read_hash64(reader)?,
+            },
+            value => {
+                return Err(DecodeError::UnknownDiscriminant {
+                    kind: "lifecycle event payload",
+                    value: u64::from(value),
+                });
+            }
+        };
+        payload
+            .validate()
+            .map_err(|_| DecodeError::InvalidField("invalid lifecycle payload"))?;
+        Ok(payload)
+    }
+}
+
+impl LifecycleEventBodyV1 {
+    /// Strictly decodes one body and rejects trailing/non-canonical encodings.
+    pub fn decode_strict(bytes: &[u8]) -> Result<Self, DecodeError> {
+        <Self as CanonicalDeserialize>::decode_strict(bytes)
+    }
+
+    /// Keyed BLAKE2b-512 digest signed by the event authority.
+    #[must_use]
+    pub fn signing_digest(&self) -> Hash64 {
+        keyed_hash(EVENT_SIGNING_DOMAIN, &self.canonical_bytes())
+    }
+
+    fn validate(&self) -> Result<(), LifecycleError> {
+        if self.version != LIFECYCLE_EVENT_VERSION_V1
+            || self.state_version != LIFECYCLE_STATE_VERSION_V1
+            || !nonzero64(&self.network_id)
+            || !nonzero64(&self.nonce)
+            || self.sequence == 0
+        {
+            return Err(LifecycleError::InvalidEvent);
+        }
+        self.payload.validate()
+    }
+}
+
+impl CanonicalSerialize for LifecycleEventBodyV1 {
+    fn encode_canonical(&self, writer: &mut CanonicalWriter) {
+        writer.write_u16(self.version);
+        writer.write_u16(self.state_version);
+        write_hash64(writer, &self.network_id);
+        writer.write_u64(self.epoch);
+        writer.write_u64(self.sequence);
+        write_hash64(writer, &self.nonce);
+        self.payload.encode_canonical(writer);
+    }
+}
+
+impl CanonicalDeserialize for LifecycleEventBodyV1 {
+    fn decode_canonical(reader: &mut CanonicalReader<'_>) -> Result<Self, DecodeError> {
+        let body = Self {
+            version: reader.read_u16()?,
+            state_version: reader.read_u16()?,
+            network_id: read_hash64(reader)?,
+            epoch: reader.read_u64()?,
+            sequence: reader.read_u64()?,
+            nonce: read_hash64(reader)?,
+            payload: LifecycleEventPayloadV1::decode_canonical(reader)?,
+        };
+        body.validate()
+            .map_err(|_| DecodeError::InvalidField("invalid lifecycle event body"))?;
+        Ok(body)
+    }
+}
+
+impl SignedLifecycleEventV1 {
+    /// Assembles an envelope from a body and externally produced signature. This API accepts no
+    /// signing/private key material.
+    #[must_use]
+    pub fn from_parts(
+        body: LifecycleEventBodyV1,
+        authority_key_id: Hash32,
+        signature: [u8; 64],
+    ) -> Self {
+        Self {
+            envelope_version: LIFECYCLE_ENVELOPE_VERSION_V1,
+            authority_key_id,
+            algorithm: ED25519_ALGORITHM_ID,
+            body,
+            signature,
+        }
+    }
+
+    /// Strictly decodes one complete envelope.
+    pub fn decode_strict(bytes: &[u8]) -> Result<Self, DecodeError> {
+        <Self as CanonicalDeserialize>::decode_strict(bytes)
+    }
+
+    /// Stable ID of the exact signed bytes.
+    #[must_use]
+    pub fn event_id(&self) -> Hash64 {
+        keyed_hash(EVENT_ID_DOMAIN, &self.canonical_bytes())
+    }
+}
+
+impl CanonicalSerialize for SignedLifecycleEventV1 {
+    fn encode_canonical(&self, writer: &mut CanonicalWriter) {
+        writer.write_u16(self.envelope_version);
+        writer.write_hash(&self.authority_key_id);
+        writer.write_u8(self.algorithm);
+        writer.write_bytes(&self.body.canonical_bytes());
+        writer.write_bytes(&self.signature);
+    }
+}
+
+impl CanonicalDeserialize for SignedLifecycleEventV1 {
+    fn decode_canonical(reader: &mut CanonicalReader<'_>) -> Result<Self, DecodeError> {
+        let envelope_version = reader.read_u16()?;
+        if envelope_version != LIFECYCLE_ENVELOPE_VERSION_V1 {
+            return Err(DecodeError::UnsupportedVersion {
+                kind: "lifecycle event envelope",
+                version: envelope_version,
+            });
+        }
+        let authority_key_id = reader.read_hash()?;
+        let algorithm = reader.read_u8()?;
+        if algorithm != ED25519_ALGORITHM_ID {
+            return Err(DecodeError::UnknownDiscriminant {
+                kind: "lifecycle signature algorithm",
+                value: u64::from(algorithm),
+            });
+        }
+        let body_bytes = reader.read_bytes_with_limit(MAX_EVENT_BODY_BYTES)?;
+        let signature: [u8; 64] = reader
+            .read_bytes_with_limit(64)?
+            .try_into()
+            .map_err(|_| DecodeError::InvalidField("lifecycle signature length"))?;
+        Ok(Self {
+            envelope_version,
+            authority_key_id,
+            algorithm,
+            body: LifecycleEventBodyV1::decode_strict(&body_bytes)?,
+            signature,
+        })
+    }
+}
+
+/// Dedicated durable lifecycle database.
+pub struct LifecycleStore {
+    connection: Connection,
+}
+
+impl LifecycleStore {
+    /// Opens or creates a lifecycle database and verifies its application/schema fingerprint.
+    pub fn open(path: impl AsRef<Path>) -> Result<Self, LifecycleError> {
+        let mut connection = Connection::open(path)?;
+        connection.busy_timeout(std::time::Duration::from_secs(30))?;
+        connection.execute_batch("PRAGMA foreign_keys=ON;")?;
+        let application_id: i32 =
+            connection.query_row("PRAGMA application_id", [], |row| row.get(0))?;
+        let user_version: i32 =
+            connection.query_row("PRAGMA user_version", [], |row| row.get(0))?;
+        if application_id == 0 && user_version == 0 {
+            let user_tables: i64 = connection.query_row(
+                "SELECT COUNT(*) FROM sqlite_master
+                 WHERE type='table' AND name NOT LIKE 'sqlite_%'",
+                [],
+                |row| row.get(0),
+            )?;
+            if user_tables != 0 {
+                return Err(LifecycleError::SchemaMismatch);
+            }
+            let fingerprint: [u8; 32] = Sha3_256::digest(SCHEMA_SQL.as_bytes()).into();
+            let transaction =
+                connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+            transaction.execute_batch(SCHEMA_SQL)?;
+            transaction.execute(
+                "INSERT INTO lifecycle_meta(key, value) VALUES('schema_sha3_256', ?1)",
+                params![fingerprint.as_slice()],
+            )?;
+            transaction.pragma_update(None, "application_id", APPLICATION_ID)?;
+            transaction.pragma_update(None, "user_version", SCHEMA_VERSION)?;
+            transaction.commit()?;
+        } else if application_id != APPLICATION_ID || user_version != SCHEMA_VERSION {
+            return Err(LifecycleError::SchemaMismatch);
+        }
+        connection.execute_batch("PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL;")?;
+        let expected: [u8; 32] = Sha3_256::digest(SCHEMA_SQL.as_bytes()).into();
+        let stored: Vec<u8> = connection
+            .query_row(
+                "SELECT value FROM lifecycle_meta WHERE key='schema_sha3_256'",
+                [],
+                |row| row.get(0),
+            )
+            .map_err(|_| LifecycleError::SchemaMismatch)?;
+        if stored.as_slice() != expected {
+            return Err(LifecycleError::SchemaMismatch);
+        }
+        Ok(Self { connection })
+    }
+
+    /// Registers a network-scoped public authority record. Exact registration is idempotent;
+    /// replacement requires an explicit new database/governance migration and fails closed here.
+    pub fn register_authority(
+        &mut self,
+        record: &LifecycleAuthorityRecord,
+    ) -> Result<bool, LifecycleError> {
+        if !nonzero64(&record.network_id)
+            || record.verifying_key.is_weak()
+            || record.valid_from_epoch > record.valid_through_epoch
+            || record
+                .revoked_at_epoch
+                .is_some_and(|epoch| epoch < record.valid_from_epoch)
+        {
+            return Err(LifecycleError::InvalidAuthority);
+        }
+        let key_id = signer_key_id(&record.verifying_key);
+        let valid_from = put_u64(record.valid_from_epoch);
+        let valid_through = put_u64(record.valid_through_epoch);
+        let revoked = record.revoked_at_epoch.map(put_u64);
+        let transaction = self
+            .connection
+            .transaction_with_behavior(TransactionBehavior::Immediate)?;
+        type AuthorityRow = (Vec<u8>, Vec<u8>, Vec<u8>, Option<Vec<u8>>, i64);
+        let existing: Option<AuthorityRow> = transaction
+            .query_row(
+                "SELECT verifying_key, valid_from_epoch, valid_through_epoch,
+                        revoked_at_epoch, permissions
+                 FROM lifecycle_authorities WHERE network_id=?1 AND authority_key_id=?2",
+                params![record.network_id.as_slice(), key_id.as_slice()],
+                |row| {
+                    Ok((
+                        row.get(0)?,
+                        row.get(1)?,
+                        row.get(2)?,
+                        row.get(3)?,
+                        row.get(4)?,
+                    ))
+                },
+            )
+            .optional()?;
+        if let Some((key, from, through, old_revoked, permissions)) = existing {
+            if key == record.verifying_key.as_bytes()
+                && from == valid_from
+                && through == valid_through
+                && old_revoked.as_deref() == revoked.as_ref().map(<[u8; 8]>::as_slice)
+                && permissions == i64::from(record.permissions.bits())
+            {
+                transaction.commit()?;
+                return Ok(false);
+            }
+            return Err(LifecycleError::InvalidAuthority);
+        }
+        transaction.execute(
+            "INSERT INTO lifecycle_authorities(
+                network_id, authority_key_id, verifying_key, valid_from_epoch,
+                valid_through_epoch, revoked_at_epoch, permissions
+             ) VALUES(?1, ?2, ?3, ?4, ?5, ?6, ?7)",
+            params![
+                record.network_id.as_slice(),
+                key_id.as_slice(),
+                record.verifying_key.as_bytes().as_slice(),
+                valid_from.as_slice(),
+                valid_through.as_slice(),
+                revoked.as_ref().map(<[u8; 8]>::as_slice),
+                i64::from(record.permissions.bits()),
+            ],
+        )?;
+        transaction.commit()?;
+        Ok(true)
+    }
+
+    /// Verifies and atomically applies one signed event. Receipt-admission events require exactly
+    /// one portable Receipt-v3 submission; every other event rejects a supplied submission.
+    pub fn apply_event(
+        &mut self,
+        event: &SignedLifecycleEventV1,
+        submission: Option<&SubmissionV3>,
+    ) -> Result<LifecycleApplyOutcome, LifecycleError> {
+        self.verify_event(event)?;
+        let wants_submission = matches!(
+            event.body.payload,
+            LifecycleEventPayloadV1::ReceiptAdmitted { .. }
+        );
+        if wants_submission != submission.is_some() {
+            return Err(LifecycleError::ReceiptInput);
+        }
+        let event_id = event.event_id();
+        let canonical_event = event.canonical_bytes();
+        let transaction = self
+            .connection
+            .transaction_with_behavior(TransactionBehavior::Immediate)?;
+        if let Some(outcome) = replay_outcome(&transaction, event, &event_id, &canonical_event)? {
+            transaction.commit()?;
+            return Ok(outcome);
+        }
+
+        let (state, payment_command_id) = match &event.body.payload {
+            LifecycleEventPayloadV1::FundingConfirmed {
+                escrow_id,
+                requester_id,
+                asset_id,
+                amount,
+                expires_epoch,
+                funding_reference,
+            } => apply_funding(
+                &transaction,
+                event,
+                &event_id,
+                escrow_id,
+                requester_id,
+                asset_id,
+                *amount,
+                *expires_epoch,
+                funding_reference,
+            )?,
+            LifecycleEventPayloadV1::EscrowLocked { escrow_id, amount } => {
+                apply_lock(&transaction, event, escrow_id, *amount)?
+            }
+            LifecycleEventPayloadV1::BondFunded {
+                worker_credential_id,
+                asset_id,
+                amount,
+                funding_reference,
+            } => apply_bond_funding(
+                &transaction,
+                event,
+                &event_id,
+                &canonical_event,
+                worker_credential_id,
+                asset_id,
+                *amount,
+                funding_reference,
+            )?,
+            LifecycleEventPayloadV1::Assigned {
+                escrow_id,
+                job_nullifier,
+                compute_set_id,
+                job_challenge,
+                issued_epoch,
+                expires_epoch,
+                worker_0,
+                worker_1,
+                bond_amount,
+                fraud_window_end,
+            } => apply_assignment(
+                &transaction,
+                event,
+                escrow_id,
+                job_nullifier,
+                compute_set_id,
+                job_challenge,
+                *issued_epoch,
+                *expires_epoch,
+                worker_0,
+                worker_1,
+                *bond_amount,
+                *fraud_window_end,
+            )?,
+            LifecycleEventPayloadV1::ReceiptAdmitted {
+                escrow_id,
+                receipt_id,
+                replica_slot,
+                submission_commitment,
+            } => apply_receipt(
+                &transaction,
+                event,
+                &event_id,
+                escrow_id,
+                receipt_id,
+                *replica_slot,
+                submission_commitment,
+                submission.ok_or(LifecycleError::ReceiptInput)?,
+            )?,
+            LifecycleEventPayloadV1::SettlementPrepared {
+                escrow_id,
+                worker_amount,
+                protocol_amount,
+                requester_amount,
+            } => apply_settlement_prepare(
+                &transaction,
+                event,
+                &event_id,
+                escrow_id,
+                *worker_amount,
+                *protocol_amount,
+                *requester_amount,
+            )?,
+            LifecycleEventPayloadV1::SettlementConfirmed {
+                escrow_id,
+                command_id,
+                rail_confirmation_id,
+            } => apply_terminal_confirmation(
+                &transaction,
+                event,
+                &event_id,
+                escrow_id,
+                command_id,
+                rail_confirmation_id,
+                1,
+            )?,
+            LifecycleEventPayloadV1::TimeoutRefundPrepared {
+                escrow_id,
+                requester_amount,
+            } => {
+                apply_timeout_prepare(&transaction, event, &event_id, escrow_id, *requester_amount)?
+            }
+            LifecycleEventPayloadV1::RefundConfirmed {
+                escrow_id,
+                command_id,
+                rail_confirmation_id,
+            } => apply_terminal_confirmation(
+                &transaction,
+                event,
+                &event_id,
+                escrow_id,
+                command_id,
+                rail_confirmation_id,
+                2,
+            )?,
+            LifecycleEventPayloadV1::SlashFinalized {
+                escrow_id,
+                worker_credential_id,
+                slash_id,
+                amount,
+                hold_until_epoch,
+            } => apply_slash(
+                &transaction,
+                event,
+                &event_id,
+                &canonical_event,
+                escrow_id,
+                worker_credential_id,
+                slash_id,
+                *amount,
+                *hold_until_epoch,
+            )?,
+            LifecycleEventPayloadV1::UnbondConfirmed {
+                worker_credential_id,
+                asset_id,
+                amount,
+                rail_confirmation_id,
+            } => apply_unbond(
+                &transaction,
+                event,
+                &event_id,
+                &canonical_event,
+                worker_credential_id,
+                asset_id,
+                *amount,
+                rail_confirmation_id,
+            )?,
+        };
+        record_event(&transaction, event, &event_id, &canonical_event, state)?;
+        transaction.commit()?;
+        Ok(LifecycleApplyOutcome {
+            event_id,
+            newly_applied: true,
+            sequence: event.body.sequence,
+            state,
+            payment_command_id,
+        })
+    }
+
+    fn verify_event(&self, event: &SignedLifecycleEventV1) -> Result<(), LifecycleError> {
+        event.body.validate()?;
+        if event.envelope_version != LIFECYCLE_ENVELOPE_VERSION_V1
+            || event.algorithm != ED25519_ALGORITHM_ID
+        {
+            return Err(LifecycleError::InvalidEvent);
+        }
+        type AuthorityRow = (Vec<u8>, Vec<u8>, Vec<u8>, Option<Vec<u8>>, i64);
+        let row: Option<AuthorityRow> = self
+            .connection
+            .query_row(
+                "SELECT verifying_key, valid_from_epoch, valid_through_epoch,
+                        revoked_at_epoch, permissions
+                 FROM lifecycle_authorities WHERE network_id=?1 AND authority_key_id=?2",
+                params![
+                    event.body.network_id.as_slice(),
+                    event.authority_key_id.as_slice()
+                ],
+                |row| {
+                    Ok((
+                        row.get(0)?,
+                        row.get(1)?,
+                        row.get(2)?,
+                        row.get(3)?,
+                        row.get(4)?,
+                    ))
+                },
+            )
+            .optional()?;
+        let (key, valid_from, valid_through, revoked, permission_bits) =
+            row.ok_or(LifecycleError::UnknownAuthority)?;
+        let valid_from = get_u64(valid_from, "authority valid_from")?;
+        let valid_through = get_u64(valid_through, "authority valid_through")?;
+        let revoked = revoked
+            .map(|bytes| get_u64(bytes, "authority revoked_at"))
+            .transpose()?;
+        if event.body.epoch < valid_from
+            || event.body.epoch > valid_through
+            || revoked.is_some_and(|epoch| event.body.epoch >= epoch)
+        {
+            return Err(LifecycleError::AuthorityInactive);
+        }
+        let permission_bits = u8::try_from(permission_bits)
+            .map_err(|_| LifecycleError::Corrupt("authority permissions"))?;
+        let permissions = LifecyclePermissions::new(permission_bits)?;
+        if !permissions.contains(event.body.payload.permission()) {
+            return Err(LifecycleError::AuthorityPermission);
+        }
+        let key: [u8; 32] = key
+            .try_into()
+            .map_err(|_| LifecycleError::Corrupt("authority verifying key"))?;
+        let verifying_key =
+            VerifyingKey::from_bytes(&key).map_err(|_| LifecycleError::InvalidAuthority)?;
+        if signer_key_id(&verifying_key) != event.authority_key_id {
+            return Err(LifecycleError::InvalidAuthority);
+        }
+        verifying_key
+            .verify_strict(
+                &event.body.signing_digest(),
+                &Signature::from_bytes(&event.signature),
+            )
+            .map_err(|_| LifecycleError::InvalidSignature)
+    }
+}
+
+fn target_snapshot(
+    transaction: &Transaction<'_>,
+    network_id: &Hash64,
+    target_kind: u8,
+    target_id: &Hash64,
+) -> Result<Option<(u64, u8, Option<Hash64>)>, LifecycleError> {
+    match target_kind {
+        1 => {
+            let row: Option<(Vec<u8>, i64, Option<Vec<u8>>)> = transaction
+                .query_row(
+                    "SELECT sequence, state, payment_command_id FROM lifecycle_escrows
+                     WHERE network_id=?1 AND escrow_id=?2",
+                    params![network_id.as_slice(), target_id.as_slice()],
+                    |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+                )
+                .optional()?;
+            row.map(|(sequence, state, command)| {
+                Ok((
+                    get_u64(sequence, "escrow sequence")?,
+                    u8::try_from(state).map_err(|_| LifecycleError::Corrupt("escrow state"))?,
+                    command
+                        .map(|bytes| get_hash64(bytes, "payment command"))
+                        .transpose()?,
+                ))
+            })
+            .transpose()
+        }
+        2 => {
+            let sequence: Option<Vec<u8>> = transaction
+                .query_row(
+                    "SELECT sequence FROM lifecycle_bonds
+                     WHERE network_id=?1 AND worker_credential_id=?2",
+                    params![network_id.as_slice(), target_id.as_slice()],
+                    |row| row.get(0),
+                )
+                .optional()?;
+            sequence
+                .map(|sequence| Ok((get_u64(sequence, "bond sequence")?, 0, None)))
+                .transpose()
+        }
+        _ => Err(LifecycleError::Corrupt("event target kind")),
+    }
+}
+
+fn replay_outcome(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    canonical_event: &[u8],
+) -> Result<Option<LifecycleApplyOutcome>, LifecycleError> {
+    type EventRow = (Vec<u8>, Vec<u8>, i64, Vec<u8>, i64);
+    let row: Option<EventRow> = transaction
+        .query_row(
+            "SELECT canonical_event, target_id, target_kind, post_sequence, post_state
+             FROM lifecycle_events WHERE network_id=?1 AND event_id=?2",
+            params![event.body.network_id.as_slice(), event_id.as_slice()],
+            |row| {
+                Ok((
+                    row.get(0)?,
+                    row.get(1)?,
+                    row.get(2)?,
+                    row.get(3)?,
+                    row.get(4)?,
+                ))
+            },
+        )
+        .optional()?;
+    if let Some((stored, target, target_kind, post_sequence, post_state)) = row {
+        if stored != canonical_event {
+            return Err(LifecycleError::ReplayConflict);
+        }
+        let target = get_hash64(target, "event target")?;
+        let target_kind =
+            u8::try_from(target_kind).map_err(|_| LifecycleError::Corrupt("event target kind"))?;
+        let post_sequence = get_u64(post_sequence, "event post sequence")?;
+        let post_state =
+            u8::try_from(post_state).map_err(|_| LifecycleError::Corrupt("event post state"))?;
+        let current = target_snapshot(transaction, &event.body.network_id, target_kind, &target)?
+            .ok_or(LifecycleError::ReplayAfterAdvance)?;
+        if current.0 != post_sequence || current.1 != post_state {
+            return Err(LifecycleError::ReplayAfterAdvance);
+        }
+        return Ok(Some(LifecycleApplyOutcome {
+            event_id: *event_id,
+            newly_applied: false,
+            sequence: post_sequence,
+            state: post_state,
+            payment_command_id: current.2,
+        }));
+    }
+    let nonce_conflict: bool = transaction.query_row(
+        "SELECT EXISTS(SELECT 1 FROM lifecycle_events
+         WHERE network_id=?1 AND authority_key_id=?2 AND event_nonce=?3)",
+        params![
+            event.body.network_id.as_slice(),
+            event.authority_key_id.as_slice(),
+            event.body.nonce.as_slice()
+        ],
+        |row| row.get(0),
+    )?;
+    if nonce_conflict {
+        return Err(LifecycleError::ReplayConflict);
+    }
+    Ok(None)
+}
+
+fn record_event(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    canonical_event: &[u8],
+    post_state: u8,
+) -> Result<(), LifecycleError> {
+    let (target_kind, target_id) = event.body.payload.target();
+    let sequence = put_u64(event.body.sequence);
+    transaction.execute(
+        "INSERT INTO lifecycle_events(
+            network_id, event_id, authority_key_id, event_nonce, target_id, target_kind,
+            event_kind, canonical_event, post_sequence, post_state
+         ) VALUES(?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
+        params![
+            event.body.network_id.as_slice(),
+            event_id.as_slice(),
+            event.authority_key_id.as_slice(),
+            event.body.nonce.as_slice(),
+            target_id.as_slice(),
+            i64::from(target_kind),
+            i64::from(event.body.payload.tag()),
+            canonical_event,
+            sequence.as_slice(),
+            i64::from(post_state),
+        ],
+    )?;
+    Ok(())
+}
+
+fn require_next_sequence(
+    current: u64,
+    event: &SignedLifecycleEventV1,
+) -> Result<(), LifecycleError> {
+    if current.checked_add(1) != Some(event.body.sequence) {
+        return Err(LifecycleError::SequenceConflict);
+    }
+    Ok(())
+}
+
+fn claim_external_reference(
+    transaction: &Transaction<'_>,
+    network_id: &Hash64,
+    reference_id: &Hash64,
+    reference_kind: u8,
+    event_id: &Hash64,
+) -> Result<(), LifecycleError> {
+    let consumed: bool = transaction.query_row(
+        "SELECT EXISTS(SELECT 1 FROM lifecycle_external_references
+         WHERE network_id=?1 AND reference_id=?2)",
+        params![network_id.as_slice(), reference_id.as_slice()],
+        |row| row.get(0),
+    )?;
+    if consumed {
+        return Err(LifecycleError::ExternalReferenceConsumed);
+    }
+    transaction.execute(
+        "INSERT INTO lifecycle_external_references(
+            network_id, reference_id, reference_kind, event_id
+         ) VALUES(?1, ?2, ?3, ?4)",
+        params![
+            network_id.as_slice(),
+            reference_id.as_slice(),
+            i64::from(reference_kind),
+            event_id.as_slice(),
+        ],
+    )?;
+    Ok(())
+}
+
+fn apply_funding(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    escrow_id: &Hash64,
+    requester_id: &Hash64,
+    asset_id: &Hash64,
+    amount: u64,
+    expires_epoch: u64,
+    funding_reference: &Hash64,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    if event.body.sequence != 1 || expires_epoch <= event.body.epoch {
+        return Err(LifecycleError::SequenceConflict);
+    }
+    claim_external_reference(
+        transaction,
+        &event.body.network_id,
+        funding_reference,
+        1,
+        event_id,
+    )?;
+    let amount_blob = put_u64(amount);
+    let epoch = put_u64(event.body.epoch);
+    let expires = put_u64(expires_epoch);
+    transaction.execute(
+        "INSERT INTO lifecycle_escrows(
+            network_id, escrow_id, state_version, state, sequence, requester_id, asset_id,
+            total_amount, funded_epoch, expires_epoch, funding_reference
+         ) VALUES(?1, ?2, 1, 1, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
+        params![
+            event.body.network_id.as_slice(),
+            escrow_id.as_slice(),
+            put_u64(event.body.sequence).as_slice(),
+            requester_id.as_slice(),
+            asset_id.as_slice(),
+            amount_blob.as_slice(),
+            epoch.as_slice(),
+            expires.as_slice(),
+            funding_reference.as_slice(),
+        ],
+    )?;
+    Ok((LifecycleEscrowState::Funded as u8, None))
+}
+
+fn apply_lock(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    escrow_id: &Hash64,
+    amount: u64,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    let row: Option<(i64, Vec<u8>, Vec<u8>, Vec<u8>)> = transaction
+        .query_row(
+            "SELECT state, sequence, total_amount, expires_epoch FROM lifecycle_escrows
+             WHERE network_id=?1 AND escrow_id=?2",
+            params![event.body.network_id.as_slice(), escrow_id.as_slice()],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
+        )
+        .optional()?;
+    let (state, sequence, total, expires) = row.ok_or(LifecycleError::NotFound)?;
+    require_next_sequence(get_u64(sequence, "escrow sequence")?, event)?;
+    if state != i64::from(LifecycleEscrowState::Funded as u8)
+        || get_u64(total, "escrow total")? != amount
+        || event.body.epoch > get_u64(expires, "escrow expiry")?
+    {
+        return Err(LifecycleError::StateConflict);
+    }
+    let updated = transaction.execute(
+        "UPDATE lifecycle_escrows SET state=2, sequence=?1
+         WHERE network_id=?2 AND escrow_id=?3 AND state=1",
+        params![
+            put_u64(event.body.sequence).as_slice(),
+            event.body.network_id.as_slice(),
+            escrow_id.as_slice()
+        ],
+    )?;
+    if updated != 1 {
+        return Err(LifecycleError::StateConflict);
+    }
+    Ok((LifecycleEscrowState::Locked as u8, None))
+}
+
+fn apply_bond_funding(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    canonical_event: &[u8],
+    worker: &Hash64,
+    asset_id: &Hash64,
+    amount: u64,
+    funding_reference: &Hash64,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    claim_external_reference(
+        transaction,
+        &event.body.network_id,
+        funding_reference,
+        2,
+        event_id,
+    )?;
+    type BondRow = (Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>);
+    let row: Option<BondRow> = transaction
+        .query_row(
+            "SELECT asset_id, total_amount, locked_amount, sequence FROM lifecycle_bonds
+             WHERE network_id=?1 AND worker_credential_id=?2",
+            params![event.body.network_id.as_slice(), worker.as_slice()],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
+        )
+        .optional()?;
+    match row {
+        None => {
+            if event.body.sequence != 1 {
+                return Err(LifecycleError::SequenceConflict);
+            }
+            transaction.execute(
+                "INSERT INTO lifecycle_bonds(
+                    network_id, worker_credential_id, asset_id, total_amount, locked_amount,
+                    hold_until_epoch, sequence
+                 ) VALUES(?1, ?2, ?3, ?4, ?5, ?5, ?6)",
+                params![
+                    event.body.network_id.as_slice(),
+                    worker.as_slice(),
+                    asset_id.as_slice(),
+                    put_u64(amount).as_slice(),
+                    put_u64(0).as_slice(),
+                    put_u64(event.body.sequence).as_slice(),
+                ],
+            )?;
+        }
+        Some((stored_asset, total, _locked, sequence)) => {
+            require_next_sequence(get_u64(sequence, "bond sequence")?, event)?;
+            if stored_asset.as_slice() != asset_id {
+                return Err(LifecycleError::BindingMismatch);
+            }
+            let new_total = get_u64(total, "bond total")?
+                .checked_add(amount)
+                .ok_or(LifecycleError::Amount)?;
+            transaction.execute(
+                "UPDATE lifecycle_bonds SET total_amount=?1, sequence=?2
+                 WHERE network_id=?3 AND worker_credential_id=?4",
+                params![
+                    put_u64(new_total).as_slice(),
+                    put_u64(event.body.sequence).as_slice(),
+                    event.body.network_id.as_slice(),
+                    worker.as_slice(),
+                ],
+            )?;
+        }
+    }
+    transaction.execute(
+        "INSERT INTO lifecycle_bond_funding(
+            network_id, funding_reference, worker_credential_id, canonical_event
+         ) VALUES(?1, ?2, ?3, ?4)",
+        params![
+            event.body.network_id.as_slice(),
+            funding_reference.as_slice(),
+            worker.as_slice(),
+            canonical_event
+        ],
+    )?;
+    Ok((0, None))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn apply_assignment(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    escrow_id: &Hash64,
+    job_nullifier: &Hash64,
+    compute_set_id: &Hash64,
+    job_challenge: &Hash64,
+    issued_epoch: u64,
+    expires_epoch: u64,
+    worker_0: &Hash64,
+    worker_1: &Hash64,
+    bond_amount: u64,
+    fraud_window_end: u64,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    type EscrowRow = (i64, Vec<u8>, Vec<u8>, Vec<u8>);
+    let row: Option<EscrowRow> = transaction
+        .query_row(
+            "SELECT state, sequence, asset_id, expires_epoch FROM lifecycle_escrows
+             WHERE network_id=?1 AND escrow_id=?2",
+            params![event.body.network_id.as_slice(), escrow_id.as_slice()],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
+        )
+        .optional()?;
+    let (state, sequence, asset, escrow_expiry) = row.ok_or(LifecycleError::NotFound)?;
+    require_next_sequence(get_u64(sequence, "escrow sequence")?, event)?;
+    let escrow_expiry = get_u64(escrow_expiry, "escrow expiry")?;
+    if state != i64::from(LifecycleEscrowState::Locked as u8)
+        || event.body.epoch < issued_epoch
+        || event.body.epoch > expires_epoch
+        || expires_epoch > escrow_expiry
+        || fraud_window_end < expires_epoch
+    {
+        return Err(LifecycleError::StateConflict);
+    }
+    let asset = get_hash64(asset, "escrow asset")?;
+    let reused: bool = transaction.query_row(
+        "SELECT EXISTS(SELECT 1 FROM lifecycle_escrows
+         WHERE network_id=?1 AND job_nullifier=?2)",
+        params![event.body.network_id.as_slice(), job_nullifier.as_slice()],
+        |row| row.get(0),
+    )?;
+    if reused {
+        return Err(LifecycleError::NullifierConsumed);
+    }
+    for (slot, worker) in [(0_u8, worker_0), (1_u8, worker_1)] {
+        type BondRow = (Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>);
+        let bond: Option<BondRow> = transaction
+            .query_row(
+                "SELECT asset_id, total_amount, locked_amount, hold_until_epoch
+                 FROM lifecycle_bonds WHERE network_id=?1 AND worker_credential_id=?2",
+                params![event.body.network_id.as_slice(), worker.as_slice()],
+                |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
+            )
+            .optional()?;
+        let (bond_asset, total, locked, hold) = bond.ok_or(LifecycleError::BondGate)?;
+        if bond_asset.as_slice() != asset {
+            return Err(LifecycleError::BondGate);
+        }
+        let total = get_u64(total, "bond total")?;
+        let locked = get_u64(locked, "bond locked")?;
+        let hold = get_u64(hold, "bond hold")?;
+        if hold != 0 && event.body.epoch <= hold {
+            return Err(LifecycleError::BondGate);
+        }
+        let new_locked = locked
+            .checked_add(bond_amount)
+            .filter(|value| *value <= total)
+            .ok_or(LifecycleError::BondGate)?;
+        transaction.execute(
+            "UPDATE lifecycle_bonds SET locked_amount=?1
+             WHERE network_id=?2 AND worker_credential_id=?3",
+            params![
+                put_u64(new_locked).as_slice(),
+                event.body.network_id.as_slice(),
+                worker.as_slice()
+            ],
+        )?;
+        transaction.execute(
+            "INSERT INTO lifecycle_assignments(
+                network_id, escrow_id, replica_slot, worker_credential_id, locked_amount,
+                status, fraud_window_end
+             ) VALUES(?1, ?2, ?3, ?4, ?5, 1, ?6)",
+            params![
+                event.body.network_id.as_slice(),
+                escrow_id.as_slice(),
+                i64::from(slot),
+                worker.as_slice(),
+                put_u64(bond_amount).as_slice(),
+                put_u64(fraud_window_end).as_slice(),
+            ],
+        )?;
+    }
+    let updated = transaction.execute(
+        "UPDATE lifecycle_escrows SET
+            state=3, sequence=?1, job_nullifier=?2, compute_set_id=?3, job_challenge=?4,
+            issued_epoch=?5, assigned_expires_epoch=?6, worker_0=?7, worker_1=?8,
+            bond_amount=?9, fraud_window_end=?10
+         WHERE network_id=?11 AND escrow_id=?12 AND state=2",
+        params![
+            put_u64(event.body.sequence).as_slice(),
+            job_nullifier.as_slice(),
+            compute_set_id.as_slice(),
+            job_challenge.as_slice(),
+            put_u64(issued_epoch).as_slice(),
+            put_u64(expires_epoch).as_slice(),
+            worker_0.as_slice(),
+            worker_1.as_slice(),
+            put_u64(bond_amount).as_slice(),
+            put_u64(fraud_window_end).as_slice(),
+            event.body.network_id.as_slice(),
+            escrow_id.as_slice(),
+        ],
+    )?;
+    if updated != 1 {
+        return Err(LifecycleError::StateConflict);
+    }
+    Ok((LifecycleEscrowState::Assigned as u8, None))
+}
+
+fn canonical_receipt_envelope(submission: &SubmissionV3) -> Vec<u8> {
+    let mut out = Vec::with_capacity(64 + 1 + 64 + 4 + submission.envelope.signature.len());
+    out.extend_from_slice(&submission.envelope.body_digest);
+    out.push(submission.envelope.algorithm);
+    out.extend_from_slice(&submission.envelope.signer_credential_id);
+    let signature_len = u32::try_from(submission.envelope.signature.len())
+        .expect("ML-DSA signature length fits u32");
+    out.extend_from_slice(&signature_len.to_le_bytes());
+    out.extend_from_slice(&submission.envelope.signature);
+    out
+}
+
+/// Commitment used by [`LifecycleEventPayloadV1::ReceiptAdmitted`]. It binds the node-canonical
+/// receipt body, ML-DSA envelope, and exact public verification key with explicit lengths.
+#[must_use]
+pub fn lifecycle_submission_commitment(submission: &SubmissionV3) -> Hash64 {
+    let body = submission.receipt.canonical_bytes();
+    let envelope = canonical_receipt_envelope(submission);
+    let mut bytes =
+        Vec::with_capacity(body.len() + envelope.len() + submission.verifying_key.len() + 24);
+    for part in [
+        body.as_slice(),
+        envelope.as_slice(),
+        submission.verifying_key.as_slice(),
+    ] {
+        bytes.extend_from_slice(&(part.len() as u64).to_le_bytes());
+        bytes.extend_from_slice(part);
+    }
+    keyed_hash(SUBMISSION_DOMAIN, &bytes)
+}
+
+#[cfg(feature = "ml-dsa")]
+#[allow(clippy::too_many_arguments, clippy::too_many_lines)]
+fn apply_receipt(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    escrow_id: &Hash64,
+    receipt_id: &Hash64,
+    replica_slot: u8,
+    submission_commitment: &Hash64,
+    submission: &SubmissionV3,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    use crate::receipt_v3::mldsa::verify_receipt_v3;
+    use crate::receipt_v3::{match_pair_v3, ReceiptV3Expectations};
+
+    type EscrowRow = (
+        i64,
+        Vec<u8>,
+        Vec<u8>,
+        Vec<u8>,
+        Vec<u8>,
+        Vec<u8>,
+        Vec<u8>,
+        Vec<u8>,
+        Vec<u8>,
+        Option<Vec<u8>>,
+        Option<Vec<u8>>,
+    );
+    let row: Option<EscrowRow> = transaction
+        .query_row(
+            "SELECT state, sequence, job_nullifier, compute_set_id, job_challenge,
+                    issued_epoch, assigned_expires_epoch, worker_0, worker_1, receipt_0, receipt_1
+             FROM lifecycle_escrows WHERE network_id=?1 AND escrow_id=?2",
+            params![event.body.network_id.as_slice(), escrow_id.as_slice()],
+            |row| {
+                Ok((
+                    row.get(0)?,
+                    row.get(1)?,
+                    row.get(2)?,
+                    row.get(3)?,
+                    row.get(4)?,
+                    row.get(5)?,
+                    row.get(6)?,
+                    row.get(7)?,
+                    row.get(8)?,
+                    row.get(9)?,
+                    row.get(10)?,
+                ))
+            },
+        )
+        .optional()?;
+    let (
+        state,
+        sequence,
+        job_nullifier,
+        compute_set_id,
+        job_challenge,
+        issued_epoch,
+        expires_epoch,
+        worker_0,
+        worker_1,
+        stored_0,
+        stored_1,
+    ) = row.ok_or(LifecycleError::NotFound)?;
+    require_next_sequence(get_u64(sequence, "escrow sequence")?, event)?;
+    if !matches!(state, 3 | 4) {
+        return Err(LifecycleError::StateConflict);
+    }
+    let job_nullifier = get_hash64(job_nullifier, "job nullifier")?;
+    let compute_set_id = get_hash64(compute_set_id, "compute set")?;
+    let job_challenge = get_hash64(job_challenge, "job challenge")?;
+    let issued_epoch = get_u64(issued_epoch, "assigned issue epoch")?;
+    let expires_epoch = get_u64(expires_epoch, "assigned expiry")?;
+    let workers = [
+        get_hash64(worker_0, "worker zero")?,
+        get_hash64(worker_1, "worker one")?,
+    ];
+    if event.body.epoch < issued_epoch || event.body.epoch > expires_epoch {
+        return Err(LifecycleError::StateConflict);
+    }
+    if submission.receipt.receipt_id() != *receipt_id
+        || lifecycle_submission_commitment(submission) != *submission_commitment
+        || submission.receipt.replica_slot != replica_slot
+        || submission.receipt.network_id != event.body.network_id
+    {
+        return Err(LifecycleError::BindingMismatch);
+    }
+    let expected = ReceiptV3Expectations {
+        network_id: event.body.network_id,
+        compute_set_id,
+        job_challenge,
+        replica_slot,
+        issued_epoch,
+        expires_epoch,
+        current_epoch: event.body.epoch,
+        registered_credential_id: workers[usize::from(replica_slot)],
+    };
+    verify_receipt_v3(
+        &submission.receipt,
+        &submission.envelope,
+        &submission.verifying_key,
+        &expected,
+    )
+    .map_err(|error| LifecycleError::ReceiptVerification(format!("{error:?}")))?;
+    let duplicate_execution: bool = transaction.query_row(
+        "SELECT EXISTS(SELECT 1 FROM lifecycle_receipts
+         WHERE network_id=?1 AND execution_nullifier=?2)",
+        params![
+            event.body.network_id.as_slice(),
+            submission.receipt.execution_nullifier.as_slice()
+        ],
+        |row| row.get(0),
+    )?;
+    if duplicate_execution {
+        return Err(LifecycleError::NullifierConsumed);
+    }
+    let canonical_body = submission.receipt.canonical_bytes();
+    let canonical_envelope = canonical_receipt_envelope(submission);
+    let canonical_json = export_receipt(submission).into_bytes();
+    if canonical_json.len() > MAX_SUBMISSION_BYTES
+        || submission.envelope.signature.len() != MLDSA87_SIGNATURE_LEN
+        || submission.verifying_key.len() != MLDSA87_VERIFYING_KEY_LEN
+    {
+        return Err(LifecycleError::ReceiptVerification(
+            "submission size or key/signature length".to_string(),
+        ));
+    }
+    transaction.execute(
+        "INSERT INTO lifecycle_receipts(
+            network_id, receipt_id, execution_nullifier, job_nullifier, escrow_id,
+            replica_slot, canonical_body, canonical_envelope, verifying_key,
+            canonical_submission_json, admission_event_id
+         ) VALUES(?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)",
+        params![
+            event.body.network_id.as_slice(),
+            receipt_id.as_slice(),
+            submission.receipt.execution_nullifier.as_slice(),
+            job_nullifier.as_slice(),
+            escrow_id.as_slice(),
+            i64::from(replica_slot),
+            canonical_body.as_slice(),
+            canonical_envelope.as_slice(),
+            submission.verifying_key.as_slice(),
+            canonical_json.as_slice(),
+            event_id.as_slice(),
+        ],
+    )?;
+    let (own_stored, peer_stored) = if replica_slot == 0 {
+        (stored_0, stored_1)
+    } else {
+        (stored_1, stored_0)
+    };
+    if own_stored.is_some() {
+        return Err(LifecycleError::NullifierConsumed);
+    }
+    if let Some(peer_id) = peer_stored {
+        let peer_id = get_hash64(peer_id, "peer receipt")?;
+        let peer_json: Vec<u8> = transaction.query_row(
+            "SELECT canonical_submission_json FROM lifecycle_receipts
+             WHERE network_id=?1 AND receipt_id=?2",
+            params![event.body.network_id.as_slice(), peer_id.as_slice()],
+            |row| row.get(0),
+        )?;
+        let peer_json = std::str::from_utf8(&peer_json)
+            .map_err(|_| LifecycleError::Corrupt("peer submission JSON"))?;
+        let peer = import_receipt(peer_json)
+            .ok_or(LifecycleError::Corrupt("peer Receipt-v3 submission"))?;
+        let pair = match_pair_v3(&peer.receipt, &submission.receipt)
+            .map_err(|error| LifecycleError::ReceiptMismatch(format!("{error:?}")))?;
+        transaction.execute(
+            "INSERT INTO lifecycle_pairs(network_id, pair_id, escrow_id, job_nullifier, ready_epoch)
+             VALUES(?1, ?2, ?3, ?4, ?5)",
+            params![
+                event.body.network_id.as_slice(),
+                pair.pair_id.as_slice(),
+                escrow_id.as_slice(),
+                job_nullifier.as_slice(),
+                put_u64(event.body.epoch).as_slice(),
+            ],
+        )?;
+        let (receipt_0, receipt_1) = if replica_slot == 0 {
+            (*receipt_id, peer_id)
+        } else {
+            (peer_id, *receipt_id)
+        };
+        let updated = transaction.execute(
+            "UPDATE lifecycle_escrows SET state=5, sequence=?1, receipt_0=?2,
+                    receipt_1=?3, pair_id=?4
+             WHERE network_id=?5 AND escrow_id=?6 AND state=4",
+            params![
+                put_u64(event.body.sequence).as_slice(),
+                receipt_0.as_slice(),
+                receipt_1.as_slice(),
+                pair.pair_id.as_slice(),
+                event.body.network_id.as_slice(),
+                escrow_id.as_slice(),
+            ],
+        )?;
+        if updated != 1 {
+            return Err(LifecycleError::StateConflict);
+        }
+        Ok((LifecycleEscrowState::EvidenceReady as u8, None))
+    } else {
+        let column = if replica_slot == 0 {
+            "receipt_0"
+        } else {
+            "receipt_1"
+        };
+        let sql = format!(
+            "UPDATE lifecycle_escrows SET state=4, sequence=?1, {column}=?2
+             WHERE network_id=?3 AND escrow_id=?4 AND state=3"
+        );
+        let updated = transaction.execute(
+            &sql,
+            params![
+                put_u64(event.body.sequence).as_slice(),
+                receipt_id.as_slice(),
+                event.body.network_id.as_slice(),
+                escrow_id.as_slice(),
+            ],
+        )?;
+        if updated != 1 {
+            return Err(LifecycleError::StateConflict);
+        }
+        Ok((LifecycleEscrowState::ReceiptOne as u8, None))
+    }
+}
+
+#[cfg(not(feature = "ml-dsa"))]
+#[allow(clippy::too_many_arguments)]
+fn apply_receipt(
+    _transaction: &Transaction<'_>,
+    _event: &SignedLifecycleEventV1,
+    _event_id: &Hash64,
+    _escrow_id: &Hash64,
+    _receipt_id: &Hash64,
+    _replica_slot: u8,
+    _submission_commitment: &Hash64,
+    _submission: &SubmissionV3,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    Err(LifecycleError::ReceiptVerification(
+        "runtime-palw was built without the ml-dsa feature".to_string(),
+    ))
+}
+
+fn payment_command_id(
+    network_id: &Hash64,
+    escrow_id: &Hash64,
+    terminal_kind: u8,
+    worker_amount: u64,
+    protocol_amount: u64,
+    requester_amount: u64,
+    prepared_event_id: &Hash64,
+) -> Hash64 {
+    let mut bytes = Vec::with_capacity(64 * 3 + 25);
+    bytes.extend_from_slice(network_id);
+    bytes.extend_from_slice(escrow_id);
+    bytes.push(terminal_kind);
+    bytes.extend_from_slice(&worker_amount.to_le_bytes());
+    bytes.extend_from_slice(&protocol_amount.to_le_bytes());
+    bytes.extend_from_slice(&requester_amount.to_le_bytes());
+    bytes.extend_from_slice(prepared_event_id);
+    keyed_hash(PAYMENT_COMMAND_DOMAIN, &bytes)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn insert_payment_command(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    escrow_id: &Hash64,
+    terminal_kind: u8,
+    worker_amount: u64,
+    protocol_amount: u64,
+    requester_amount: u64,
+) -> Result<Hash64, LifecycleError> {
+    let command_id = payment_command_id(
+        &event.body.network_id,
+        escrow_id,
+        terminal_kind,
+        worker_amount,
+        protocol_amount,
+        requester_amount,
+        event_id,
+    );
+    transaction.execute(
+        "INSERT INTO lifecycle_payment_commands(
+            network_id, command_id, escrow_id, terminal_kind, worker_amount,
+            protocol_amount, requester_amount, prepared_epoch, prepared_event_id
+         ) VALUES(?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
+        params![
+            event.body.network_id.as_slice(),
+            command_id.as_slice(),
+            escrow_id.as_slice(),
+            i64::from(terminal_kind),
+            put_u64(worker_amount).as_slice(),
+            put_u64(protocol_amount).as_slice(),
+            put_u64(requester_amount).as_slice(),
+            put_u64(event.body.epoch).as_slice(),
+            event_id.as_slice(),
+        ],
+    )?;
+    Ok(command_id)
+}
+
+fn ensure_active_assignment_bonds(
+    transaction: &Transaction<'_>,
+    network_id: &Hash64,
+    escrow_id: &Hash64,
+    epoch: u64,
+) -> Result<(), LifecycleError> {
+    let mut statement = transaction.prepare(
+        "SELECT a.worker_credential_id, a.locked_amount, a.fraud_window_end,
+                b.total_amount, b.locked_amount, b.hold_until_epoch
+         FROM lifecycle_assignments a
+         JOIN lifecycle_bonds b
+           ON b.network_id=a.network_id AND b.worker_credential_id=a.worker_credential_id
+         WHERE a.network_id=?1 AND a.escrow_id=?2 AND a.status=1
+         ORDER BY a.replica_slot",
+    )?;
+    let rows = statement.query_map(
+        params![network_id.as_slice(), escrow_id.as_slice()],
+        |row| {
+            Ok((
+                row.get::<_, Vec<u8>>(0)?,
+                row.get::<_, Vec<u8>>(1)?,
+                row.get::<_, Vec<u8>>(2)?,
+                row.get::<_, Vec<u8>>(3)?,
+                row.get::<_, Vec<u8>>(4)?,
+                row.get::<_, Vec<u8>>(5)?,
+            ))
+        },
+    )?;
+    let rows = rows.collect::<Result<Vec<_>, _>>()?;
+    if rows.len() != 2 {
+        return Err(LifecycleError::BondGate);
+    }
+    for (_worker, assigned, fraud_end, total, locked, hold) in rows {
+        let assigned = get_u64(assigned, "assignment bond")?;
+        let fraud_end = get_u64(fraud_end, "fraud window")?;
+        let total = get_u64(total, "bond total")?;
+        let locked = get_u64(locked, "bond locked")?;
+        let hold = get_u64(hold, "bond hold")?;
+        if epoch <= fraud_end || locked < assigned || total < locked || (hold != 0 && epoch <= hold)
+        {
+            return Err(if epoch <= fraud_end {
+                LifecycleError::FraudWindowOpen
+            } else {
+                LifecycleError::BondGate
+            });
+        }
+    }
+    Ok(())
+}
+
+fn apply_settlement_prepare(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    escrow_id: &Hash64,
+    worker_amount: u64,
+    protocol_amount: u64,
+    requester_amount: u64,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    let row: Option<(i64, Vec<u8>, Vec<u8>, Vec<u8>)> = transaction
+        .query_row(
+            "SELECT state, sequence, total_amount, fraud_window_end
+             FROM lifecycle_escrows WHERE network_id=?1 AND escrow_id=?2",
+            params![event.body.network_id.as_slice(), escrow_id.as_slice()],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
+        )
+        .optional()?;
+    let (state, sequence, total, fraud_end) = row.ok_or(LifecycleError::NotFound)?;
+    require_next_sequence(get_u64(sequence, "escrow sequence")?, event)?;
+    let total = get_u64(total, "escrow total")?;
+    let distribution = worker_amount
+        .checked_add(protocol_amount)
+        .and_then(|sum| sum.checked_add(requester_amount))
+        .ok_or(LifecycleError::Amount)?;
+    if state != i64::from(LifecycleEscrowState::EvidenceReady as u8) || distribution != total {
+        return Err(LifecycleError::StateConflict);
+    }
+    if event.body.epoch <= get_u64(fraud_end, "fraud window")? {
+        return Err(LifecycleError::FraudWindowOpen);
+    }
+    ensure_active_assignment_bonds(
+        transaction,
+        &event.body.network_id,
+        escrow_id,
+        event.body.epoch,
+    )?;
+    let command_id = insert_payment_command(
+        transaction,
+        event,
+        event_id,
+        escrow_id,
+        1,
+        worker_amount,
+        protocol_amount,
+        requester_amount,
+    )?;
+    let updated = transaction.execute(
+        "UPDATE lifecycle_escrows SET state=6, sequence=?1, payment_command_id=?2
+         WHERE network_id=?3 AND escrow_id=?4 AND state=5",
+        params![
+            put_u64(event.body.sequence).as_slice(),
+            command_id.as_slice(),
+            event.body.network_id.as_slice(),
+            escrow_id.as_slice(),
+        ],
+    )?;
+    if updated != 1 {
+        return Err(LifecycleError::StateConflict);
+    }
+    Ok((
+        LifecycleEscrowState::SettlementPrepared as u8,
+        Some(command_id),
+    ))
+}
+
+fn release_active_assignments(
+    transaction: &Transaction<'_>,
+    network_id: &Hash64,
+    escrow_id: &Hash64,
+) -> Result<(), LifecycleError> {
+    let mut statement = transaction.prepare(
+        "SELECT worker_credential_id, locked_amount, fraud_window_end
+         FROM lifecycle_assignments
+         WHERE network_id=?1 AND escrow_id=?2 AND status=1",
+    )?;
+    let rows = statement.query_map(
+        params![network_id.as_slice(), escrow_id.as_slice()],
+        |row| {
+            Ok((
+                row.get::<_, Vec<u8>>(0)?,
+                row.get::<_, Vec<u8>>(1)?,
+                row.get::<_, Vec<u8>>(2)?,
+            ))
+        },
+    )?;
+    let rows = rows.collect::<Result<Vec<_>, _>>()?;
+    drop(statement);
+    for (worker, amount, fraud_end) in rows {
+        let worker = get_hash64(worker, "assignment worker")?;
+        let amount = get_u64(amount, "assignment amount")?;
+        let fraud_end = get_u64(fraud_end, "assignment fraud window")?;
+        let bond: Option<(Vec<u8>, Vec<u8>)> = transaction
+            .query_row(
+                "SELECT locked_amount, hold_until_epoch FROM lifecycle_bonds
+                 WHERE network_id=?1 AND worker_credential_id=?2",
+                params![network_id.as_slice(), worker.as_slice()],
+                |row| Ok((row.get(0)?, row.get(1)?)),
+            )
+            .optional()?;
+        let (locked, hold) = bond.ok_or(LifecycleError::BondGate)?;
+        let locked = get_u64(locked, "bond locked")?;
+        let new_locked = locked.checked_sub(amount).ok_or(LifecycleError::BondGate)?;
+        let hold = get_u64(hold, "bond hold")?.max(fraud_end);
+        transaction.execute(
+            "UPDATE lifecycle_bonds SET locked_amount=?1, hold_until_epoch=?2
+             WHERE network_id=?3 AND worker_credential_id=?4",
+            params![
+                put_u64(new_locked).as_slice(),
+                put_u64(hold).as_slice(),
+                network_id.as_slice(),
+                worker.as_slice(),
+            ],
+        )?;
+        transaction.execute(
+            "UPDATE lifecycle_assignments SET status=2
+             WHERE network_id=?1 AND escrow_id=?2 AND worker_credential_id=?3 AND status=1",
+            params![
+                network_id.as_slice(),
+                escrow_id.as_slice(),
+                worker.as_slice()
+            ],
+        )?;
+    }
+    Ok(())
+}
+
+fn apply_terminal_confirmation(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    escrow_id: &Hash64,
+    command_id: &Hash64,
+    rail_confirmation_id: &Hash64,
+    terminal_kind: u8,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    let row: Option<(i64, Vec<u8>, Option<Vec<u8>>)> = transaction
+        .query_row(
+            "SELECT state, sequence, payment_command_id FROM lifecycle_escrows
+             WHERE network_id=?1 AND escrow_id=?2",
+            params![event.body.network_id.as_slice(), escrow_id.as_slice()],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+        )
+        .optional()?;
+    let (state, sequence, stored_command) = row.ok_or(LifecycleError::NotFound)?;
+    require_next_sequence(get_u64(sequence, "escrow sequence")?, event)?;
+    let expected_state = if terminal_kind == 1 {
+        LifecycleEscrowState::SettlementPrepared as u8
+    } else {
+        LifecycleEscrowState::RefundPrepared as u8
+    };
+    let terminal_state = if terminal_kind == 1 {
+        LifecycleEscrowState::Settled as u8
+    } else {
+        LifecycleEscrowState::Refunded as u8
+    };
+    if state != i64::from(expected_state)
+        || stored_command
+            .map(|bytes| get_hash64(bytes, "escrow payment command"))
+            .transpose()?
+            != Some(*command_id)
+    {
+        return Err(LifecycleError::TerminalBinding);
+    }
+    let command: Option<(i64, Vec<u8>, Option<Vec<u8>>)> = transaction
+        .query_row(
+            "SELECT terminal_kind, prepared_epoch, confirmation_id
+             FROM lifecycle_payment_commands WHERE network_id=?1 AND command_id=?2 AND escrow_id=?3",
+            params![
+                event.body.network_id.as_slice(),
+                command_id.as_slice(),
+                escrow_id.as_slice()
+            ],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+        )
+        .optional()?;
+    let (stored_kind, prepared_epoch, confirmation) =
+        command.ok_or(LifecycleError::TerminalBinding)?;
+    if stored_kind != i64::from(terminal_kind)
+        || confirmation.is_some()
+        || event.body.epoch < get_u64(prepared_epoch, "payment prepared epoch")?
+    {
+        return Err(LifecycleError::TerminalBinding);
+    }
+    claim_external_reference(
+        transaction,
+        &event.body.network_id,
+        rail_confirmation_id,
+        if terminal_kind == 1 { 3 } else { 4 },
+        event_id,
+    )?;
+    let updated = transaction.execute(
+        "UPDATE lifecycle_payment_commands SET confirmation_id=?1
+         WHERE network_id=?2 AND command_id=?3 AND confirmation_id IS NULL",
+        params![
+            rail_confirmation_id.as_slice(),
+            event.body.network_id.as_slice(),
+            command_id.as_slice()
+        ],
+    )?;
+    if updated != 1 {
+        return Err(LifecycleError::TerminalBinding);
+    }
+    release_active_assignments(transaction, &event.body.network_id, escrow_id)?;
+    let updated = transaction.execute(
+        "UPDATE lifecycle_escrows SET state=?1, sequence=?2, terminal_confirmation_id=?3
+         WHERE network_id=?4 AND escrow_id=?5 AND state=?6",
+        params![
+            i64::from(terminal_state),
+            put_u64(event.body.sequence).as_slice(),
+            rail_confirmation_id.as_slice(),
+            event.body.network_id.as_slice(),
+            escrow_id.as_slice(),
+            i64::from(expected_state),
+        ],
+    )?;
+    if updated != 1 {
+        return Err(LifecycleError::StateConflict);
+    }
+    Ok((terminal_state, Some(*command_id)))
+}
+
+fn apply_timeout_prepare(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    escrow_id: &Hash64,
+    requester_amount: u64,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    let row: Option<(i64, Vec<u8>, Vec<u8>, Vec<u8>)> = transaction
+        .query_row(
+            "SELECT state, sequence, total_amount,
+                    COALESCE(assigned_expires_epoch, expires_epoch)
+             FROM lifecycle_escrows WHERE network_id=?1 AND escrow_id=?2",
+            params![event.body.network_id.as_slice(), escrow_id.as_slice()],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
+        )
+        .optional()?;
+    let (state, sequence, total, expires) = row.ok_or(LifecycleError::NotFound)?;
+    require_next_sequence(get_u64(sequence, "escrow sequence")?, event)?;
+    if !(1..=5).contains(&state)
+        || requester_amount != get_u64(total, "escrow total")?
+        || event.body.epoch <= get_u64(expires, "escrow timeout")?
+    {
+        return Err(LifecycleError::StateConflict);
+    }
+    let command_id = insert_payment_command(
+        transaction,
+        event,
+        event_id,
+        escrow_id,
+        2,
+        0,
+        0,
+        requester_amount,
+    )?;
+    transaction.execute(
+        "UPDATE lifecycle_escrows SET state=8, sequence=?1, payment_command_id=?2
+         WHERE network_id=?3 AND escrow_id=?4 AND state=?5",
+        params![
+            put_u64(event.body.sequence).as_slice(),
+            command_id.as_slice(),
+            event.body.network_id.as_slice(),
+            escrow_id.as_slice(),
+            state,
+        ],
+    )?;
+    Ok((LifecycleEscrowState::RefundPrepared as u8, Some(command_id)))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn apply_slash(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    canonical_event: &[u8],
+    escrow_id: &Hash64,
+    worker: &Hash64,
+    slash_id: &Hash64,
+    amount: u64,
+    hold_until_epoch: u64,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    claim_external_reference(transaction, &event.body.network_id, slash_id, 5, event_id)?;
+    let row: Option<(i64, Vec<u8>, Vec<u8>, Option<Vec<u8>>)> = transaction
+        .query_row(
+            "SELECT state, sequence, total_amount, payment_command_id
+             FROM lifecycle_escrows WHERE network_id=?1 AND escrow_id=?2",
+            params![event.body.network_id.as_slice(), escrow_id.as_slice()],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
+        )
+        .optional()?;
+    let (state, sequence, escrow_total, old_command) = row.ok_or(LifecycleError::NotFound)?;
+    require_next_sequence(get_u64(sequence, "escrow sequence")?, event)?;
+    if !matches!(state, 3 | 4 | 5 | 8 | 9) || hold_until_epoch < event.body.epoch {
+        return Err(LifecycleError::StateConflict);
+    }
+    let assignment: Option<(Vec<u8>, i64, Vec<u8>)> = transaction
+        .query_row(
+            "SELECT locked_amount, status, fraud_window_end FROM lifecycle_assignments
+             WHERE network_id=?1 AND escrow_id=?2 AND worker_credential_id=?3",
+            params![
+                event.body.network_id.as_slice(),
+                escrow_id.as_slice(),
+                worker.as_slice()
+            ],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+        )
+        .optional()?;
+    let (assigned, assignment_status, fraud_window_end) =
+        assignment.ok_or(LifecycleError::BondGate)?;
+    let after_refund = state == i64::from(LifecycleEscrowState::Refunded as u8);
+    let expected_assignment_status = if after_refund { 2 } else { 1 };
+    if assignment_status != expected_assignment_status
+        || get_u64(assigned, "assignment locked")? != amount
+        || (after_refund
+            && event.body.epoch > get_u64(fraud_window_end, "assignment fraud window")?)
+    {
+        return Err(LifecycleError::BondGate);
+    }
+    let bond: Option<(Vec<u8>, Vec<u8>, Vec<u8>)> = transaction
+        .query_row(
+            "SELECT total_amount, locked_amount, hold_until_epoch FROM lifecycle_bonds
+             WHERE network_id=?1 AND worker_credential_id=?2",
+            params![event.body.network_id.as_slice(), worker.as_slice()],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+        )
+        .optional()?;
+    let (total, locked, old_hold) = bond.ok_or(LifecycleError::BondGate)?;
+    let new_total = get_u64(total, "bond total")?
+        .checked_sub(amount)
+        .ok_or(LifecycleError::BondGate)?;
+    let locked = get_u64(locked, "bond locked")?;
+    let old_hold = get_u64(old_hold, "bond hold")?;
+    if after_refund && event.body.epoch > old_hold {
+        return Err(LifecycleError::BondGate);
+    }
+    let new_locked = if after_refund {
+        locked
+    } else {
+        locked.checked_sub(amount).ok_or(LifecycleError::BondGate)?
+    };
+    let hold = old_hold.max(hold_until_epoch);
+    transaction.execute(
+        "UPDATE lifecycle_bonds SET total_amount=?1, locked_amount=?2, hold_until_epoch=?3
+         WHERE network_id=?4 AND worker_credential_id=?5",
+        params![
+            put_u64(new_total).as_slice(),
+            put_u64(new_locked).as_slice(),
+            put_u64(hold).as_slice(),
+            event.body.network_id.as_slice(),
+            worker.as_slice(),
+        ],
+    )?;
+    transaction.execute(
+        "UPDATE lifecycle_assignments SET status=3
+         WHERE network_id=?1 AND escrow_id=?2 AND worker_credential_id=?3 AND status=?4",
+        params![
+            event.body.network_id.as_slice(),
+            escrow_id.as_slice(),
+            worker.as_slice(),
+            expected_assignment_status,
+        ],
+    )?;
+    transaction.execute(
+        "INSERT INTO lifecycle_slashes(
+            network_id, slash_id, escrow_id, worker_credential_id, amount, canonical_event
+         ) VALUES(?1, ?2, ?3, ?4, ?5, ?6)",
+        params![
+            event.body.network_id.as_slice(),
+            slash_id.as_slice(),
+            escrow_id.as_slice(),
+            worker.as_slice(),
+            put_u64(amount).as_slice(),
+            canonical_event,
+        ],
+    )?;
+    let command_id = if matches!(state, 8 | 9) {
+        old_command
+            .map(|bytes| get_hash64(bytes, "refund command"))
+            .transpose()?
+            .ok_or(LifecycleError::Corrupt("refund command"))?
+    } else {
+        insert_payment_command(
+            transaction,
+            event,
+            event_id,
+            escrow_id,
+            2,
+            0,
+            0,
+            get_u64(escrow_total, "escrow total")?,
+        )?
+    };
+    let post_state = if after_refund {
+        LifecycleEscrowState::Refunded as u8
+    } else {
+        LifecycleEscrowState::RefundPrepared as u8
+    };
+    transaction.execute(
+        "UPDATE lifecycle_escrows SET state=?1, sequence=?2, payment_command_id=?3
+         WHERE network_id=?4 AND escrow_id=?5",
+        params![
+            i64::from(post_state),
+            put_u64(event.body.sequence).as_slice(),
+            command_id.as_slice(),
+            event.body.network_id.as_slice(),
+            escrow_id.as_slice(),
+        ],
+    )?;
+    Ok((post_state, Some(command_id)))
+}
+
+fn apply_unbond(
+    transaction: &Transaction<'_>,
+    event: &SignedLifecycleEventV1,
+    event_id: &Hash64,
+    canonical_event: &[u8],
+    worker: &Hash64,
+    asset_id: &Hash64,
+    amount: u64,
+    rail_confirmation_id: &Hash64,
+) -> Result<(u8, Option<Hash64>), LifecycleError> {
+    claim_external_reference(
+        transaction,
+        &event.body.network_id,
+        rail_confirmation_id,
+        6,
+        event_id,
+    )?;
+    type BondRow = (Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>);
+    let row: Option<BondRow> = transaction
+        .query_row(
+            "SELECT asset_id, total_amount, locked_amount, hold_until_epoch, sequence
+             FROM lifecycle_bonds WHERE network_id=?1 AND worker_credential_id=?2",
+            params![event.body.network_id.as_slice(), worker.as_slice()],
+            |row| {
+                Ok((
+                    row.get(0)?,
+                    row.get(1)?,
+                    row.get(2)?,
+                    row.get(3)?,
+                    row.get(4)?,
+                ))
+            },
+        )
+        .optional()?;
+    let (stored_asset, total, locked, hold, sequence) = row.ok_or(LifecycleError::NotFound)?;
+    require_next_sequence(get_u64(sequence, "bond sequence")?, event)?;
+    let total = get_u64(total, "bond total")?;
+    if stored_asset.as_slice() != asset_id
+        || get_u64(locked, "bond locked")? != 0
+        || event.body.epoch <= get_u64(hold, "bond hold")?
+        || amount > total
+    {
+        return Err(LifecycleError::BondGate);
+    }
+    transaction.execute(
+        "UPDATE lifecycle_bonds SET total_amount=?1, sequence=?2
+         WHERE network_id=?3 AND worker_credential_id=?4",
+        params![
+            put_u64(total - amount).as_slice(),
+            put_u64(event.body.sequence).as_slice(),
+            event.body.network_id.as_slice(),
+            worker.as_slice(),
+        ],
+    )?;
+    transaction.execute(
+        "INSERT INTO lifecycle_unbonds(
+            network_id, confirmation_id, worker_credential_id, amount, canonical_event
+         ) VALUES(?1, ?2, ?3, ?4, ?5)",
+        params![
+            event.body.network_id.as_slice(),
+            rail_confirmation_id.as_slice(),
+            worker.as_slice(),
+            put_u64(amount).as_slice(),
+            canonical_event,
+        ],
+    )?;
+    Ok((0, None))
+}
+
+fn escrow_state_from_i64(value: i64) -> Result<LifecycleEscrowState, LifecycleError> {
+    match value {
+        1 => Ok(LifecycleEscrowState::Funded),
+        2 => Ok(LifecycleEscrowState::Locked),
+        3 => Ok(LifecycleEscrowState::Assigned),
+        4 => Ok(LifecycleEscrowState::ReceiptOne),
+        5 => Ok(LifecycleEscrowState::EvidenceReady),
+        6 => Ok(LifecycleEscrowState::SettlementPrepared),
+        7 => Ok(LifecycleEscrowState::Settled),
+        8 => Ok(LifecycleEscrowState::RefundPrepared),
+        9 => Ok(LifecycleEscrowState::Refunded),
+        _ => Err(LifecycleError::Corrupt("escrow state")),
+    }
+}
+
+fn optional_hash64(
+    value: Option<Vec<u8>>,
+    field: &'static str,
+) -> Result<Option<Hash64>, LifecycleError> {
+    value.map(|bytes| get_hash64(bytes, field)).transpose()
+}
+
+/// JSON outpoint used by the selected-chain Object-v2 export context.
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct LifecycleNodeDaOutpointV2 {
+    /// Exact 64-byte transaction id as 128 hexadecimal characters.
+    pub transaction_id: String,
+    /// Output index.
+    pub index: u32,
+}
+
+/// Node provider-owner to Receipt-v3 session-key authorization, encoded exactly as the node's
+/// `PalwProviderSessionAuthorizationV1` Borsh fields.
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct LifecycleNodeDaSessionAuthorizationV1 {
+    /// Authorization schema version; exactly 1.
+    pub version: u16,
+    /// Node PALW `u32` network domain (distinct from the 64-byte genesis identity).
+    pub network_id: u32,
+    /// Provider bond named by the authorization.
+    pub provider_bond: LifecycleNodeDaOutpointV2,
+    /// Exact 2592-byte ML-DSA-87 owner verification key, hexadecimal.
+    pub owner_public_key_hex: String,
+    /// Exact Receipt-v3 verification/session key, hexadecimal.
+    pub session_public_key_hex: String,
+    /// First authorized receipt epoch.
+    pub valid_from_epoch: u64,
+    /// Last authorized receipt epoch.
+    pub valid_until_epoch: u64,
+    /// Nonzero 64-byte authorization nonce, hexadecimal.
+    pub authorization_nonce: String,
+    /// Exact 4627-byte ML-DSA-87 owner signature, hexadecimal.
+    pub signature_hex: String,
+}
+
+/// External selected-chain facts that the Qwen lifecycle database cannot infer. Supplying this
+/// contract lets the exporter wrap its two authenticated Receipt-v3 submissions in the exact node
+/// Object-v2 bytes; the node still independently resolves these facts and verifies every signature
+/// through `ConsensusApi::palw_admit_da_object` before storage/publication.
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct LifecycleNodeDaObjectV2Context {
+    /// Exactly `misaka.palw.node-da-object-v2-context.v1`.
+    pub schema: String,
+    /// Selected network/genesis identity; must equal the lifecycle network.
+    pub network_id: String,
+    /// On-chain batch id.
+    pub batch_id: String,
+    /// On-chain leaf index.
+    pub leaf_index: u32,
+    /// Provider A bond.
+    pub provider_a_bond: LifecycleNodeDaOutpointV2,
+    /// Provider B bond.
+    pub provider_b_bond: LifecycleNodeDaOutpointV2,
+    /// Leaf-selected compute set expected by both receipts.
+    pub receipt_v3_compute_set_id: String,
+    /// Leaf-selected job challenge expected by both receipts.
+    pub receipt_v3_job_challenge: String,
+    /// Leaf-selected issue epoch.
+    pub receipt_v3_issued_epoch: u64,
+    /// Leaf-selected expiry epoch.
+    pub receipt_v3_expires_epoch: u64,
+    /// Leaf private match commitment; must equal the lifecycle verified pair id.
+    pub private_match_commitment: String,
+    /// Provider A owner-to-session authorization.
+    pub session_authorization_a: LifecycleNodeDaSessionAuthorizationV1,
+    /// Provider B owner-to-session authorization.
+    pub session_authorization_b: LifecycleNodeDaSessionAuthorizationV1,
+}
+
+fn context_hash(value: &str, field: &'static str) -> Result<Hash64, LifecycleError> {
+    lifecycle_hash64_from_hex(value).ok_or(LifecycleError::InvalidNodeDaContext(field))
+}
+
+fn context_bytes(
+    value: &str,
+    expected: usize,
+    field: &'static str,
+) -> Result<Vec<u8>, LifecycleError> {
+    let bytes = from_hex(value).ok_or(LifecycleError::InvalidNodeDaContext(field))?;
+    if bytes.len() != expected {
+        return Err(LifecycleError::InvalidNodeDaContext(field));
+    }
+    Ok(bytes)
+}
+
+fn context_outpoint(value: &LifecycleNodeDaOutpointV2) -> Result<(Hash64, u32), LifecycleError> {
+    Ok((
+        context_hash(&value.transaction_id, "provider bond transaction id")?,
+        value.index,
+    ))
+}
+
+fn append_outpoint(object: &mut Vec<u8>, outpoint: &(Hash64, u32)) {
+    object.extend_from_slice(&outpoint.0);
+    object.extend_from_slice(&outpoint.1.to_le_bytes());
+}
+
+fn append_borsh_vec(object: &mut Vec<u8>, bytes: &[u8]) -> Result<(), LifecycleError> {
+    let len = u32::try_from(bytes.len()).map_err(|_| LifecycleError::BridgeTooLarge)?;
+    object.extend_from_slice(&len.to_le_bytes());
+    object.extend_from_slice(bytes);
+    Ok(())
+}
+
+fn append_node_session_authorization(
+    object: &mut Vec<u8>,
+    authorization: &LifecycleNodeDaSessionAuthorizationV1,
+    expected_bond: &(Hash64, u32),
+    expected_session_key: &[u8],
+    issued_epoch: u64,
+    expires_epoch: u64,
+) -> Result<(), LifecycleError> {
+    let bond = context_outpoint(&authorization.provider_bond)?;
+    let owner_key = context_bytes(
+        &authorization.owner_public_key_hex,
+        MLDSA87_VERIFYING_KEY_LEN,
+        "owner public key",
+    )?;
+    let session_key = context_bytes(
+        &authorization.session_public_key_hex,
+        MLDSA87_VERIFYING_KEY_LEN,
+        "session public key",
+    )?;
+    let nonce = context_hash(&authorization.authorization_nonce, "authorization nonce")?;
+    let signature = context_bytes(
+        &authorization.signature_hex,
+        MLDSA87_SIGNATURE_LEN,
+        "authorization signature",
+    )?;
+    if authorization.version != 1
+        || bond != *expected_bond
+        || session_key != expected_session_key
+        || !nonzero64(&nonce)
+        || authorization.valid_from_epoch > issued_epoch
+        || authorization.valid_until_epoch < expires_epoch
+        || authorization
+            .valid_until_epoch
+            .saturating_sub(authorization.valid_from_epoch)
+            > 64
+    {
+        return Err(LifecycleError::InvalidNodeDaContext(
+            "owner-to-session authorization binding/window",
+        ));
+    }
+    object.extend_from_slice(&authorization.version.to_le_bytes());
+    object.extend_from_slice(&authorization.network_id.to_le_bytes());
+    append_outpoint(object, &bond);
+    append_borsh_vec(object, &owner_key)?;
+    append_borsh_vec(object, &session_key)?;
+    object.extend_from_slice(&authorization.valid_from_epoch.to_le_bytes());
+    object.extend_from_slice(&authorization.valid_until_epoch.to_le_bytes());
+    object.extend_from_slice(&nonce);
+    append_borsh_vec(object, &signature)
+}
+
+impl LifecycleStore {
+    /// Reads one durable escrow snapshot without exposing signed blobs or other large material.
+    pub fn escrow_status(
+        &self,
+        network_id: &Hash64,
+        escrow_id: &Hash64,
+    ) -> Result<LifecycleEscrowStatus, LifecycleError> {
+        type StatusRow = (
+            i64,
+            Vec<u8>,
+            Vec<u8>,
+            Option<Vec<u8>>,
+            Option<Vec<u8>>,
+            Option<Vec<u8>>,
+            Option<Vec<u8>>,
+        );
+        let row: Option<StatusRow> = self
+            .connection
+            .query_row(
+                "SELECT state, sequence, total_amount, job_nullifier, pair_id,
+                        payment_command_id, terminal_confirmation_id
+                 FROM lifecycle_escrows WHERE network_id=?1 AND escrow_id=?2",
+                params![network_id.as_slice(), escrow_id.as_slice()],
+                |row| {
+                    Ok((
+                        row.get(0)?,
+                        row.get(1)?,
+                        row.get(2)?,
+                        row.get(3)?,
+                        row.get(4)?,
+                        row.get(5)?,
+                        row.get(6)?,
+                    ))
+                },
+            )
+            .optional()?;
+        let (state, sequence, total, job, pair, command, terminal) =
+            row.ok_or(LifecycleError::NotFound)?;
+        Ok(LifecycleEscrowStatus {
+            network_id: *network_id,
+            escrow_id: *escrow_id,
+            state: escrow_state_from_i64(state)?,
+            sequence: get_u64(sequence, "escrow sequence")?,
+            total_amount: get_u64(total, "escrow total")?,
+            job_nullifier: optional_hash64(job, "job nullifier")?,
+            pair_id: optional_hash64(pair, "pair ID")?,
+            payment_command_id: optional_hash64(command, "payment command")?,
+            terminal_confirmation_id: optional_hash64(terminal, "terminal confirmation")?,
+        })
+    }
+
+    /// Stable compact JSON for operator status tooling.
+    pub fn escrow_status_json(
+        &self,
+        network_id: &Hash64,
+        escrow_id: &Hash64,
+    ) -> Result<String, LifecycleError> {
+        let status = self.escrow_status(network_id, escrow_id)?;
+        Ok(serde_json::json!({
+            "schema": "misaka.palw.lifecycle-status.v1",
+            "network_id": to_hex(&status.network_id),
+            "escrow_id": to_hex(&status.escrow_id),
+            "state": format!("{:?}", status.state),
+            "state_tag": status.state as u8,
+            "state_version": LIFECYCLE_STATE_VERSION_V1,
+            "sequence": status.sequence,
+            "total_amount": status.total_amount,
+            "job_nullifier": status.job_nullifier.map(|value| to_hex(&value)),
+            "pair_id": status.pair_id.map(|value| to_hex(&value)),
+            "payment_command_id": status.payment_command_id.map(|value| to_hex(&value)),
+            "terminal_confirmation_id": status.terminal_confirmation_id.map(|value| to_hex(&value)),
+            "consensus_enforced": false,
+        })
+        .to_string())
+    }
+
+    /// Exports the legacy lifecycle-local bridge object. It remains available for archived tooling,
+    /// but deliberately reports `node_da_object_compatible: false` because it lacks provider bonds
+    /// and owner-to-session authorizations.
+    pub fn export_bridge_json(
+        &self,
+        network_id: &Hash64,
+        escrow_id: &Hash64,
+    ) -> Result<String, LifecycleError> {
+        self.export_bridge_json_inner(network_id, escrow_id, None)
+    }
+
+    /// Exports the exact node `PalwReceiptDaObjectV2` outer bytes by combining the lifecycle-owned
+    /// authenticated Receipt-v3 pair with explicit selected-chain leaf/bond/authorization context.
+    /// Compatibility does not bypass the node: operators submit the resulting bytes through
+    /// `ConsensusApi::palw_admit_da_object`, which re-resolves chain state and verifies all signatures.
+    pub fn export_node_da_object_v2_json(
+        &self,
+        network_id: &Hash64,
+        escrow_id: &Hash64,
+        context_json: &str,
+    ) -> Result<String, LifecycleError> {
+        let context: LifecycleNodeDaObjectV2Context = serde_json::from_str(context_json)
+            .map_err(|_| LifecycleError::InvalidNodeDaContext("JSON/schema"))?;
+        if context.schema != "misaka.palw.node-da-object-v2-context.v1" {
+            return Err(LifecycleError::InvalidNodeDaContext("schema"));
+        }
+        self.export_bridge_json_inner(network_id, escrow_id, Some(&context))
+    }
+
+    fn export_bridge_json_inner(
+        &self,
+        network_id: &Hash64,
+        escrow_id: &Hash64,
+        node_context: Option<&LifecycleNodeDaObjectV2Context>,
+    ) -> Result<String, LifecycleError> {
+        type PairRow = (Vec<u8>, Vec<u8>, Vec<u8>, i64);
+        let pair: Option<PairRow> = self
+            .connection
+            .query_row(
+                "SELECT e.job_nullifier, e.pair_id, p.ready_epoch, e.state
+                 FROM lifecycle_escrows e
+                 JOIN lifecycle_pairs p
+                   ON p.network_id=e.network_id AND p.escrow_id=e.escrow_id
+                 WHERE e.network_id=?1 AND e.escrow_id=?2",
+                params![network_id.as_slice(), escrow_id.as_slice()],
+                |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
+            )
+            .optional()?;
+        let (job_nullifier, pair_id, ready_epoch, state) = pair.ok_or(LifecycleError::NotFound)?;
+        if state < i64::from(LifecycleEscrowState::EvidenceReady as u8) {
+            return Err(LifecycleError::StateConflict);
+        }
+        let job_nullifier = get_hash64(job_nullifier, "job nullifier")?;
+        let pair_id = get_hash64(pair_id, "pair ID")?;
+        let ready_epoch = get_u64(ready_epoch, "ready epoch")?;
+        let mut statement = self.connection.prepare(
+            "SELECT replica_slot, receipt_id, execution_nullifier, canonical_body,
+                    canonical_envelope, verifying_key, canonical_submission_json
+             FROM lifecycle_receipts
+             WHERE network_id=?1 AND escrow_id=?2 ORDER BY replica_slot",
+        )?;
+        let rows = statement.query_map(
+            params![network_id.as_slice(), escrow_id.as_slice()],
+            |row| {
+                Ok((
+                    row.get::<_, i64>(0)?,
+                    row.get::<_, Vec<u8>>(1)?,
+                    row.get::<_, Vec<u8>>(2)?,
+                    row.get::<_, Vec<u8>>(3)?,
+                    row.get::<_, Vec<u8>>(4)?,
+                    row.get::<_, Vec<u8>>(5)?,
+                    row.get::<_, Vec<u8>>(6)?,
+                ))
+            },
+        )?;
+        let rows = rows.collect::<Result<Vec<_>, _>>()?;
+        if rows.len() != 2 {
+            return Err(LifecycleError::Corrupt("matched pair receipt cardinality"));
+        }
+
+        let node_bindings = node_context
+            .map(|context| {
+                let context_network = context_hash(&context.network_id, "network id")?;
+                let batch_id = context_hash(&context.batch_id, "batch id")?;
+                let compute_set =
+                    context_hash(&context.receipt_v3_compute_set_id, "Receipt-v3 compute set")?;
+                let job_challenge = context_hash(
+                    &context.receipt_v3_job_challenge,
+                    "Receipt-v3 job challenge",
+                )?;
+                let match_commitment = context_hash(
+                    &context.private_match_commitment,
+                    "private match commitment",
+                )?;
+                let bond_a = context_outpoint(&context.provider_a_bond)?;
+                let bond_b = context_outpoint(&context.provider_b_bond)?;
+                if context_network != *network_id
+                    || match_commitment != pair_id
+                    || bond_a == bond_b
+                    || context.receipt_v3_issued_epoch > context.receipt_v3_expires_epoch
+                    || context.session_authorization_a.network_id
+                        != context.session_authorization_b.network_id
+                {
+                    return Err(LifecycleError::InvalidNodeDaContext(
+                        "selected-chain binding",
+                    ));
+                }
+                Ok((batch_id, compute_set, job_challenge, bond_a, bond_b))
+            })
+            .transpose()?;
+
+        let object_version = if node_bindings.is_some() {
+            LIFECYCLE_BRIDGE_VERSION_V2
+        } else {
+            LIFECYCLE_BRIDGE_VERSION_V1
+        };
+        let mut object = Vec::new();
+        object.extend_from_slice(&object_version.to_le_bytes());
+        if let Some((batch_id, _, _, bond_a, bond_b)) = &node_bindings {
+            object.extend_from_slice(network_id);
+            object.extend_from_slice(batch_id);
+            object.extend_from_slice(
+                &node_context
+                    .expect("bindings imply context")
+                    .leaf_index
+                    .to_le_bytes(),
+            );
+            append_outpoint(&mut object, bond_a);
+            append_outpoint(&mut object, bond_b);
+        } else {
+            object.extend_from_slice(network_id);
+            object.extend_from_slice(escrow_id);
+            object.extend_from_slice(&job_nullifier);
+            object.extend_from_slice(&pair_id);
+            object.extend_from_slice(&ready_epoch.to_le_bytes());
+            let receipt_count =
+                u16::try_from(rows.len()).map_err(|_| LifecycleError::Corrupt("receipt count"))?;
+            object.extend_from_slice(&receipt_count.to_le_bytes());
+        }
+        let mut receipt_json = Vec::with_capacity(2);
+        let mut session_keys = Vec::with_capacity(2);
+        for (
+            position,
+            (slot, receipt_id, execution, body, envelope, verifying_key, submission_json),
+        ) in rows.into_iter().enumerate()
+        {
+            let slot = u8::try_from(slot).map_err(|_| LifecycleError::Corrupt("receipt slot"))?;
+            let receipt_id = get_hash64(receipt_id, "receipt ID")?;
+            let execution = get_hash64(execution, "execution nullifier")?;
+            if body.len() != crate::receipt_v3::ComputeReceiptV3::CANONICAL_LEN
+                || verifying_key.len() != MLDSA87_VERIFYING_KEY_LEN
+            {
+                return Err(LifecycleError::Corrupt("Receipt-v3 bridge material"));
+            }
+            if let Some((_, compute_set, job_challenge, _, _)) = &node_bindings {
+                let context = node_context.expect("bindings imply context");
+                let body_network: Hash64 = body[2..66]
+                    .try_into()
+                    .map_err(|_| LifecycleError::Corrupt("Receipt-v3 network"))?;
+                let body_compute_set: Hash64 = body[66..130]
+                    .try_into()
+                    .map_err(|_| LifecycleError::Corrupt("Receipt-v3 compute set"))?;
+                let body_job_challenge: Hash64 = body[130..194]
+                    .try_into()
+                    .map_err(|_| LifecycleError::Corrupt("Receipt-v3 challenge"))?;
+                let body_slot = body[659];
+                let issued_epoch = u64::from_le_bytes(
+                    body[724..732]
+                        .try_into()
+                        .map_err(|_| LifecycleError::Corrupt("Receipt-v3 issue epoch"))?,
+                );
+                let expires_epoch = u64::from_le_bytes(
+                    body[732..740]
+                        .try_into()
+                        .map_err(|_| LifecycleError::Corrupt("Receipt-v3 expiry epoch"))?,
+                );
+                if slot != u8::try_from(position).unwrap_or(u8::MAX)
+                    || body_slot != slot
+                    || body_network != *network_id
+                    || body_compute_set != *compute_set
+                    || body_job_challenge != *job_challenge
+                    || issued_epoch != context.receipt_v3_issued_epoch
+                    || expires_epoch != context.receipt_v3_expires_epoch
+                {
+                    return Err(LifecycleError::InvalidNodeDaContext(
+                        "Receipt-v3 leaf expectations",
+                    ));
+                }
+                // `ComputeReceiptV3` is all fixed-width fields, so its canonical body is its exact
+                // Borsh encoding. `canonical_envelope` already carries Borsh's u32 Vec length.
+                object.extend_from_slice(&body);
+                object.extend_from_slice(&envelope);
+                session_keys.push(verifying_key.clone());
+            } else {
+                object.push(slot);
+                object.extend_from_slice(&receipt_id);
+                object.extend_from_slice(&execution);
+                for part in [
+                    body.as_slice(),
+                    envelope.as_slice(),
+                    verifying_key.as_slice(),
+                ] {
+                    let part_len =
+                        u32::try_from(part.len()).map_err(|_| LifecycleError::BridgeTooLarge)?;
+                    object.extend_from_slice(&part_len.to_le_bytes());
+                    object.extend_from_slice(part);
+                }
+            }
+            let submission: serde_json::Value = serde_json::from_slice(&submission_json)
+                .map_err(|_| LifecycleError::Corrupt("receipt submission JSON"))?;
+            receipt_json.push(serde_json::json!({
+                "replica_slot": slot,
+                "receipt_id": to_hex(&receipt_id),
+                "execution_nullifier": to_hex(&execution),
+                "canonical_body_hex": to_hex(&body),
+                "canonical_envelope_hex": to_hex(&envelope),
+                "verifying_key_hex": to_hex(&verifying_key),
+                "portable_submission": submission,
+            }));
+        }
+        if let Some((_, _, _, bond_a, bond_b)) = &node_bindings {
+            let context = node_context.expect("bindings imply context");
+            if session_keys.len() != 2 {
+                return Err(LifecycleError::Corrupt(
+                    "Receipt-v3 session key cardinality",
+                ));
+            }
+            append_node_session_authorization(
+                &mut object,
+                &context.session_authorization_a,
+                bond_a,
+                &session_keys[0],
+                context.receipt_v3_issued_epoch,
+                context.receipt_v3_expires_epoch,
+            )?;
+            append_node_session_authorization(
+                &mut object,
+                &context.session_authorization_b,
+                bond_b,
+                &session_keys[1],
+                context.receipt_v3_issued_epoch,
+                context.receipt_v3_expires_epoch,
+            )?;
+            object.extend_from_slice(&pair_id);
+        }
+        if object.len() > DA_MAX_OBJECT_BYTES {
+            return Err(LifecycleError::BridgeTooLarge);
+        }
+        let object_id = keyed_hash(BRIDGE_OBJECT_DOMAIN, &object);
+        let (commitment, proofs) = bridge_da_material(object_version, &object)?;
+        let proofs_json: Vec<_> = proofs
+            .iter()
+            .map(|proof| {
+                serde_json::json!({
+                    "version": 1,
+                    "object_version": commitment.object_version,
+                    "object_len": commitment.object_len,
+                    "chunk_count": commitment.chunk_count,
+                    "chunk_index": proof.chunk_index,
+                    "chunk_hex": to_hex(&proof.chunk),
+                    "siblings": proof.siblings.iter().map(|hash| to_hex(hash)).collect::<Vec<_>>(),
+                })
+            })
+            .collect();
+        let node_compatible = object_version == LIFECYCLE_BRIDGE_VERSION_V2;
+        let schema = if node_compatible {
+            "misaka.palw.lifecycle-receipt-v3-node-da-bridge.v2"
+        } else {
+            "misaka.palw.lifecycle-receipt-v3-bridge.v1"
+        };
+        let object_schema = if node_compatible {
+            "misaka.palw.receipt-da-object.v2"
+        } else {
+            "misaka.palw.lifecycle-v3-bridge-object.v1"
+        };
+        Ok(serde_json::json!({
+            "schema": schema,
+            "artifact_version": object_version,
+            "network_id": to_hex(network_id),
+            "escrow_id": to_hex(escrow_id),
+            "job_nullifier": to_hex(&job_nullifier),
+            "pair_id": to_hex(&pair_id),
+            "ready_epoch": ready_epoch,
+            "receipt_contract": {
+                "version": 3,
+                "canonical_body": "node-owned fixed-width little-endian Receipt-v3 bytes",
+                "signature": "ML-DSA-87",
+                "pair_cardinality": 2,
+            },
+            "receipts": receipt_json,
+            "selected_chain_context": node_context,
+            "bridge_object": {
+                "schema": object_schema,
+                "object_id": to_hex(&object_id),
+                "bytes_hex": to_hex(&object),
+            },
+            "da": {
+                "algorithm": "PALW DA-01 fixed-16KiB keyed-BLAKE2b-512 chunk tree",
+                "object_version": commitment.object_version,
+                "object_len": commitment.object_len,
+                "chunk_count": commitment.chunk_count,
+                "root": to_hex(&commitment.root),
+                "proofs": proofs_json,
+                "da_chunk_algorithm_compatible": true,
+                "node_da_object_compatible": node_compatible,
+            },
+            "enforcement": {
+                "consensus_enforced": false,
+                "node_receipt_v3_contract": if node_compatible {
+                    "submit bridge_object.bytes_hex through ConsensusApi::palw_admit_da_object"
+                } else {
+                    "legacy authenticated off-chain artifact"
+                },
+                "node_admission_required": node_compatible,
+                "missing_consensus_enforcement": if node_compatible {
+                    vec!["settlement command execution/finality in node consensus"]
+                } else {
+                    vec![
+                        "selected-chain Receipt-v3 admission",
+                        "Receipt-v3 PalwReceiptDaObject variant",
+                        "settlement command execution/finality in node consensus"
+                    ]
+                }
+            }
+        })
+        .to_string())
+    }
+}
+
+fn da_expected_chunk_count(object_len: usize) -> Result<u16, LifecycleError> {
+    if object_len == 0 || object_len > DA_MAX_OBJECT_BYTES {
+        return Err(LifecycleError::BridgeTooLarge);
+    }
+    u16::try_from(object_len.div_ceil(DA_CHUNK_BYTES)).map_err(|_| LifecycleError::BridgeTooLarge)
+}
+
+fn da_chunk_leaf(
+    object_version: u16,
+    object_len: u32,
+    chunk_count: u16,
+    chunk_index: u16,
+    chunk: &[u8],
+) -> Hash64 {
+    let mut bytes = Vec::with_capacity(14 + chunk.len());
+    bytes.extend_from_slice(&object_version.to_le_bytes());
+    bytes.extend_from_slice(&object_len.to_le_bytes());
+    bytes.extend_from_slice(&chunk_count.to_le_bytes());
+    bytes.extend_from_slice(&chunk_index.to_le_bytes());
+    let chunk_len = u32::try_from(chunk.len()).expect("DA chunk bound fits u32");
+    bytes.extend_from_slice(&chunk_len.to_le_bytes());
+    bytes.extend_from_slice(chunk);
+    keyed_hash(DA_CHUNK_LEAF_DOMAIN, &bytes)
+}
+
+fn da_empty_leaf(object_version: u16, object_len: u32, chunk_count: u16, index: u16) -> Hash64 {
+    let mut bytes = Vec::with_capacity(10);
+    bytes.extend_from_slice(&object_version.to_le_bytes());
+    bytes.extend_from_slice(&object_len.to_le_bytes());
+    bytes.extend_from_slice(&chunk_count.to_le_bytes());
+    bytes.extend_from_slice(&index.to_le_bytes());
+    keyed_hash(DA_CHUNK_EMPTY_DOMAIN, &bytes)
+}
+
+fn da_node(left: &Hash64, right: &Hash64) -> Hash64 {
+    let mut bytes = Vec::with_capacity(128);
+    bytes.extend_from_slice(left);
+    bytes.extend_from_slice(right);
+    keyed_hash(DA_CHUNK_NODE_DOMAIN, &bytes)
+}
+
+fn da_finalize(object_version: u16, object_len: u32, chunk_count: u16, apex: &Hash64) -> Hash64 {
+    let mut bytes = Vec::with_capacity(72);
+    bytes.extend_from_slice(&object_version.to_le_bytes());
+    bytes.extend_from_slice(&object_len.to_le_bytes());
+    bytes.extend_from_slice(&chunk_count.to_le_bytes());
+    bytes.extend_from_slice(apex);
+    keyed_hash(DA_OBJECT_ROOT_DOMAIN, &bytes)
+}
+
+fn da_tree_leaves(object_version: u16, object: &[u8], chunk_count: u16) -> Vec<Hash64> {
+    let width = usize::from(chunk_count).next_power_of_two();
+    let object_len = u32::try_from(object.len()).expect("DA object bound fits u32");
+    (0..width)
+        .map(|index| {
+            if index < usize::from(chunk_count) {
+                let start = index * DA_CHUNK_BYTES;
+                let end = (start + DA_CHUNK_BYTES).min(object.len());
+                da_chunk_leaf(
+                    object_version,
+                    object_len,
+                    chunk_count,
+                    u16::try_from(index).expect("DA tree width fits u16"),
+                    &object[start..end],
+                )
+            } else {
+                da_empty_leaf(
+                    object_version,
+                    object_len,
+                    chunk_count,
+                    u16::try_from(index).expect("DA tree width fits u16"),
+                )
+            }
+        })
+        .collect()
+}
+
+fn bridge_da_material(
+    object_version: u16,
+    object: &[u8],
+) -> Result<(LifecycleBridgeDaCommitmentV1, Vec<LifecycleBridgeDaProofV1>), LifecycleError> {
+    let chunk_count = da_expected_chunk_count(object.len())?;
+    let object_len = u32::try_from(object.len()).map_err(|_| LifecycleError::BridgeTooLarge)?;
+    if !matches!(
+        object_version,
+        LIFECYCLE_BRIDGE_VERSION_V1 | LIFECYCLE_BRIDGE_VERSION_V2
+    ) {
+        return Err(LifecycleError::InvalidNodeDaContext("object version"));
+    }
+    let leaves = da_tree_leaves(object_version, object, chunk_count);
+    let mut apex_level = leaves.clone();
+    while apex_level.len() > 1 {
+        apex_level = apex_level
+            .chunks_exact(2)
+            .map(|pair| da_node(&pair[0], &pair[1]))
+            .collect();
+    }
+    let commitment = LifecycleBridgeDaCommitmentV1 {
+        object_version,
+        object_len,
+        chunk_count,
+        root: da_finalize(object_version, object_len, chunk_count, &apex_level[0]),
+    };
+    let mut proofs = Vec::with_capacity(usize::from(chunk_count));
+    for chunk_index in 0..chunk_count {
+        let start = usize::from(chunk_index) * DA_CHUNK_BYTES;
+        let end = (start + DA_CHUNK_BYTES).min(object.len());
+        let mut level = leaves.clone();
+        let mut index = usize::from(chunk_index);
+        let mut siblings = Vec::new();
+        while level.len() > 1 {
+            siblings.push(level[index ^ 1]);
+            index /= 2;
+            level = level
+                .chunks_exact(2)
+                .map(|pair| da_node(&pair[0], &pair[1]))
+                .collect();
+        }
+        proofs.push(LifecycleBridgeDaProofV1 {
+            chunk_index,
+            chunk: object[start..end].to_vec(),
+            siblings,
+        });
+    }
+    Ok((commitment, proofs))
+}
+
+/// Parses one exact 64-byte lowercase/uppercase hexadecimal identity.
+#[must_use]
+pub fn lifecycle_hash64_from_hex(value: &str) -> Option<Hash64> {
+    from_hex(value)?.try_into().ok()
+}
+
+/// Encodes a signed event for an operational `.hex` input file.
+#[must_use]
+pub fn lifecycle_event_to_hex(event: &SignedLifecycleEventV1) -> String {
+    to_hex(&event.canonical_bytes())
+}
+
+/// Strictly decodes a signed event from hexadecimal canonical bytes.
+pub fn lifecycle_event_from_hex(value: &str) -> Result<SignedLifecycleEventV1, LifecycleError> {
+    let bytes = from_hex(value.trim()).ok_or(LifecycleError::InvalidEvent)?;
+    SignedLifecycleEventV1::decode_strict(&bytes).map_err(LifecycleError::from)
+}
+
+#[cfg(all(test, feature = "ml-dsa"))]
+mod tests {
+    use super::*;
+    use crate::receipt_v3::mldsa::verifying_key_and_credential_from_seed;
+    use crate::receipt_v3::ImplementationTelemetry;
+    use crate::testnet::flow::issue_receipt_v3;
+    use crate::testnet::{JobSpecV2, WorkerResultV1};
+    use ed25519_dalek::{Signer, SigningKey};
+    use ml_dsa::{ExpandedSigningKey, MlDsa87};
+    use std::sync::{Arc, Barrier};
+
+    fn h(byte: u8) -> Hash64 {
+        [byte; 64]
+    }
+
+    fn temp_db(label: &str) -> std::path::PathBuf {
+        let mut random = [0_u8; 8];
+        getrandom::getrandom(&mut random).unwrap();
+        std::env::temp_dir().join(format!(
+            "palw-lifecycle-{label}-{}-{}.sqlite",
+            std::process::id(),
+            u64::from_le_bytes(random)
+        ))
+    }
+
+    fn signed(
+        key: &SigningKey,
+        network_id: Hash64,
+        epoch: u64,
+        sequence: u64,
+        nonce: u8,
+        payload: LifecycleEventPayloadV1,
+    ) -> SignedLifecycleEventV1 {
+        let body = LifecycleEventBodyV1 {
+            version: LIFECYCLE_EVENT_VERSION_V1,
+            state_version: LIFECYCLE_STATE_VERSION_V1,
+            network_id,
+            epoch,
+            sequence,
+            nonce: h(nonce),
+            payload,
+        };
+        let signature = key.sign(&body.signing_digest()).to_bytes();
+        SignedLifecycleEventV1::from_parts(body, signer_key_id(&key.verifying_key()), signature)
+    }
+
+    fn register(store: &mut LifecycleStore, key: &SigningKey, network_id: Hash64) {
+        assert!(store
+            .register_authority(&LifecycleAuthorityRecord {
+                network_id,
+                verifying_key: key.verifying_key(),
+                valid_from_epoch: 0,
+                valid_through_epoch: 1_000,
+                revoked_at_epoch: None,
+                permissions: LifecyclePermissions::all(),
+            })
+            .unwrap());
+    }
+
+    fn result(class: u8) -> WorkerResultV1 {
+        WorkerResultV1 {
+            tokens: vec![1, 2, 3],
+            schedule_root: h(0x51),
+            execution_root: h(0x52),
+            route_root: h(0x53),
+            state_root: h(0x54),
+            canonical_compute_units: 1234,
+            stop_reason: 0,
+            telemetry: ImplementationTelemetry {
+                runtime_class_id: [class; 32],
+                runtime_manifest_hash: [class.wrapping_add(1); 32],
+            },
+        }
+    }
+
+    struct ReadyFixture {
+        network: Hash64,
+        escrow: Hash64,
+        asset: Hash64,
+        worker_0: Hash64,
+        worker_1: Hash64,
+        submission_0: SubmissionV3,
+        submission_1: SubmissionV3,
+    }
+
+    fn node_session_authorization(
+        owner_seed: u8,
+        network_id: u32,
+        bond: LifecycleNodeDaOutpointV2,
+        session_public_key: &[u8],
+        nonce: Hash64,
+    ) -> LifecycleNodeDaSessionAuthorizationV1 {
+        let owner = ExpandedSigningKey::<MlDsa87>::from_seed(&[owner_seed; 32].into());
+        let owner_public_key = owner.verifying_key().encode().to_vec();
+        let bond_txid = lifecycle_hash64_from_hex(&bond.transaction_id).unwrap();
+        let mut preimage = Vec::new();
+        preimage.extend_from_slice(&1_u16.to_le_bytes());
+        preimage.extend_from_slice(&network_id.to_le_bytes());
+        preimage.extend_from_slice(&bond_txid);
+        preimage.extend_from_slice(&bond.index.to_le_bytes());
+        preimage.extend_from_slice(&(owner_public_key.len() as u64).to_le_bytes());
+        preimage.extend_from_slice(&owner_public_key);
+        preimage.extend_from_slice(&(session_public_key.len() as u64).to_le_bytes());
+        preimage.extend_from_slice(session_public_key);
+        preimage.extend_from_slice(&5_u64.to_le_bytes());
+        preimage.extend_from_slice(&20_u64.to_le_bytes());
+        preimage.extend_from_slice(&nonce);
+        let digest = keyed_hash(b"misaka-palw-provider-session-v1", &preimage);
+        let signature = owner
+            .sign_deterministic(&digest, b"PALWProviderSessionV1")
+            .unwrap()
+            .encode()
+            .to_vec();
+        LifecycleNodeDaSessionAuthorizationV1 {
+            version: 1,
+            network_id,
+            provider_bond: bond,
+            owner_public_key_hex: to_hex(&owner_public_key),
+            session_public_key_hex: to_hex(session_public_key),
+            valid_from_epoch: 5,
+            valid_until_epoch: 20,
+            authorization_nonce: to_hex(&nonce),
+            signature_hex: to_hex(&signature),
+        }
+    }
+
+    fn node_da_context(
+        store: &LifecycleStore,
+        fixture: &ReadyFixture,
+    ) -> LifecycleNodeDaObjectV2Context {
+        let bond_a = LifecycleNodeDaOutpointV2 {
+            transaction_id: to_hex(&h(0xc1)),
+            index: 0,
+        };
+        let bond_b = LifecycleNodeDaOutpointV2 {
+            transaction_id: to_hex(&h(0xc2)),
+            index: 1,
+        };
+        let pair_id = store
+            .escrow_status(&fixture.network, &fixture.escrow)
+            .unwrap()
+            .pair_id
+            .unwrap();
+        LifecycleNodeDaObjectV2Context {
+            schema: "misaka.palw.node-da-object-v2-context.v1".to_string(),
+            network_id: to_hex(&fixture.network),
+            batch_id: to_hex(&fixture.escrow),
+            leaf_index: 7,
+            provider_a_bond: bond_a.clone(),
+            provider_b_bond: bond_b.clone(),
+            receipt_v3_compute_set_id: to_hex(&h(0x31)),
+            receipt_v3_job_challenge: to_hex(&h(0x32)),
+            receipt_v3_issued_epoch: 5,
+            receipt_v3_expires_epoch: 20,
+            private_match_commitment: to_hex(&pair_id),
+            session_authorization_a: node_session_authorization(
+                0xa1,
+                110,
+                bond_a,
+                &fixture.submission_0.verifying_key,
+                h(0xd1),
+            ),
+            session_authorization_b: node_session_authorization(
+                0xb2,
+                110,
+                bond_b,
+                &fixture.submission_1.verifying_key,
+                h(0xd2),
+            ),
+        }
+    }
+
+    fn fund_bond(
+        store: &mut LifecycleStore,
+        key: &SigningKey,
+        network: Hash64,
+        worker: Hash64,
+        asset: Hash64,
+        nonce: u8,
+        reference: u8,
+        amount: u64,
+    ) {
+        let event = signed(
+            key,
+            network,
+            1,
+            1,
+            nonce,
+            LifecycleEventPayloadV1::BondFunded {
+                worker_credential_id: worker,
+                asset_id: asset,
+                amount,
+                funding_reference: h(reference),
+            },
+        );
+        assert!(store.apply_event(&event, None).unwrap().newly_applied);
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn create_assigned(
+        store: &mut LifecycleStore,
+        key: &SigningKey,
+        network: Hash64,
+        escrow: Hash64,
+        asset: Hash64,
+        worker_0: Hash64,
+        worker_1: Hash64,
+        job_nullifier: Hash64,
+        compute_set_id: Hash64,
+        job_challenge: Hash64,
+        nonce_base: u8,
+    ) {
+        let fund = signed(
+            key,
+            network,
+            1,
+            1,
+            nonce_base,
+            LifecycleEventPayloadV1::FundingConfirmed {
+                escrow_id: escrow,
+                requester_id: h(0xa0),
+                asset_id: asset,
+                amount: 100,
+                expires_epoch: 40,
+                funding_reference: h(nonce_base.wrapping_add(80)),
+            },
+        );
+        store.apply_event(&fund, None).unwrap();
+        let lock = signed(
+            key,
+            network,
+            2,
+            2,
+            nonce_base.wrapping_add(1),
+            LifecycleEventPayloadV1::EscrowLocked {
+                escrow_id: escrow,
+                amount: 100,
+            },
+        );
+        store.apply_event(&lock, None).unwrap();
+        let assignment = signed(
+            key,
+            network,
+            5,
+            3,
+            nonce_base.wrapping_add(2),
+            LifecycleEventPayloadV1::Assigned {
+                escrow_id: escrow,
+                job_nullifier,
+                compute_set_id,
+                job_challenge,
+                issued_epoch: 5,
+                expires_epoch: 20,
+                worker_0,
+                worker_1,
+                bond_amount: 10,
+                fraud_window_end: 30,
+            },
+        );
+        store.apply_event(&assignment, None).unwrap();
+    }
+
+    fn create_ready(
+        store: &mut LifecycleStore,
+        key: &SigningKey,
+        network: Hash64,
+        nonce_base: u8,
+    ) -> ReadyFixture {
+        let escrow = h(nonce_base.wrapping_add(1));
+        let asset = h(0x70);
+        let worker_0 = verifying_key_and_credential_from_seed(&[0x11; 32]).1;
+        let worker_1 = verifying_key_and_credential_from_seed(&[0x22; 32]).1;
+        fund_bond(store, key, network, worker_0, asset, nonce_base, 0xb1, 100);
+        fund_bond(
+            store,
+            key,
+            network,
+            worker_1,
+            asset,
+            nonce_base.wrapping_add(1),
+            0xb2,
+            100,
+        );
+        let compute = h(0x31);
+        let challenge = h(0x32);
+        create_assigned(
+            store,
+            key,
+            network,
+            escrow,
+            asset,
+            worker_0,
+            worker_1,
+            h(0x33),
+            compute,
+            challenge,
+            nonce_base.wrapping_add(2),
+        );
+        let spec_0 = JobSpecV2 {
+            network_id: network,
+            compute_set_id: compute,
+            job_challenge: challenge,
+            replica_slot: 0,
+            prompt_token_count: 2,
+            issued_epoch: 5,
+            expires_epoch: 20,
+        };
+        let spec_1 = JobSpecV2 {
+            replica_slot: 1,
+            ..spec_0.clone()
+        };
+        let submission_0 = issue_receipt_v3(&spec_0, &result(1), worker_0, &[0x11; 32]).unwrap();
+        let submission_1 = issue_receipt_v3(&spec_1, &result(2), worker_1, &[0x22; 32]).unwrap();
+        for (sequence, nonce, submission) in [
+            (4, nonce_base.wrapping_add(5), &submission_0),
+            (5, nonce_base.wrapping_add(6), &submission_1),
+        ] {
+            let admit = signed(
+                key,
+                network,
+                10,
+                sequence,
+                nonce,
+                LifecycleEventPayloadV1::ReceiptAdmitted {
+                    escrow_id: escrow,
+                    receipt_id: submission.receipt.receipt_id(),
+                    replica_slot: submission.receipt.replica_slot,
+                    submission_commitment: lifecycle_submission_commitment(submission),
+                },
+            );
+            store.apply_event(&admit, Some(submission)).unwrap();
+        }
+        assert_eq!(
+            store.escrow_status(&network, &escrow).unwrap().state,
+            LifecycleEscrowState::EvidenceReady
+        );
+        ReadyFixture {
+            network,
+            escrow,
+            asset,
+            worker_0,
+            worker_1,
+            submission_0,
+            submission_1,
+        }
+    }
+
+    fn prepare_settlement(
+        store: &mut LifecycleStore,
+        key: &SigningKey,
+        fixture: &ReadyFixture,
+        nonce: u8,
+    ) -> (SignedLifecycleEventV1, Hash64) {
+        let prepare = signed(
+            key,
+            fixture.network,
+            31,
+            6,
+            nonce,
+            LifecycleEventPayloadV1::SettlementPrepared {
+                escrow_id: fixture.escrow,
+                worker_amount: 90,
+                protocol_amount: 5,
+                requester_amount: 5,
+            },
+        );
+        let outcome = store.apply_event(&prepare, None).unwrap();
+        (
+            prepare,
+            outcome
+                .payment_command_id
+                .expect("prepared payment command"),
+        )
+    }
+
+    #[test]
+    fn unowned_nonempty_sqlite_database_is_never_claimed() {
+        let path = temp_db("unowned");
+        let connection = Connection::open(&path).unwrap();
+        connection
+            .execute("CREATE TABLE user_data(value TEXT NOT NULL)", [])
+            .unwrap();
+        connection
+            .execute("INSERT INTO user_data(value) VALUES('preserve-me')", [])
+            .unwrap();
+        drop(connection);
+        assert!(matches!(
+            LifecycleStore::open(&path),
+            Err(LifecycleError::SchemaMismatch)
+        ));
+        let connection = Connection::open(&path).unwrap();
+        let value: String = connection
+            .query_row("SELECT value FROM user_data", [], |row| row.get(0))
+            .unwrap();
+        let lifecycle_tables: i64 = connection
+            .query_row(
+                "SELECT COUNT(*) FROM sqlite_master WHERE name LIKE 'lifecycle_%'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(value, "preserve-me");
+        assert_eq!(lifecycle_tables, 0);
+        let application_id: i32 = connection
+            .query_row("PRAGMA application_id", [], |row| row.get(0))
+            .unwrap();
+        assert_eq!(application_id, 0);
+    }
+
+    #[test]
+    fn restart_exact_replay_signed_terminal_and_honest_bridge() {
+        let path = temp_db("happy");
+        let key = SigningKey::from_bytes(&[0x42; 32]);
+        let network = h(0x10);
+        let fixture = {
+            let mut store = LifecycleStore::open(&path).unwrap();
+            register(&mut store, &key, network);
+            create_ready(&mut store, &key, network, 1)
+        };
+        let mut store = LifecycleStore::open(&path).unwrap();
+        let second_escrow = h(0x90);
+        create_assigned(
+            &mut store,
+            &key,
+            network,
+            second_escrow,
+            fixture.asset,
+            fixture.worker_0,
+            fixture.worker_1,
+            h(0x34),
+            h(0x31),
+            h(0x32),
+            80,
+        );
+        let reused_execution = signed(
+            &key,
+            network,
+            10,
+            4,
+            83,
+            LifecycleEventPayloadV1::ReceiptAdmitted {
+                escrow_id: second_escrow,
+                receipt_id: fixture.submission_0.receipt.receipt_id(),
+                replica_slot: 0,
+                submission_commitment: lifecycle_submission_commitment(&fixture.submission_0),
+            },
+        );
+        assert!(matches!(
+            store.apply_event(&reused_execution, Some(&fixture.submission_0)),
+            Err(LifecycleError::NullifierConsumed)
+        ));
+        let bridge: serde_json::Value =
+            serde_json::from_str(&store.export_bridge_json(&network, &fixture.escrow).unwrap())
+                .unwrap();
+        assert_eq!(bridge["enforcement"]["consensus_enforced"], false);
+        assert_eq!(bridge["da"]["node_da_object_compatible"], false);
+        assert_eq!(bridge["da"]["da_chunk_algorithm_compatible"], true);
+        assert_eq!(bridge["receipts"].as_array().unwrap().len(), 2);
+
+        let node_context = node_da_context(&store, &fixture);
+        let golden: serde_json::Value = serde_json::from_str(include_str!(
+            "../test-data/receipt_da_object_v2_golden_v1.json"
+        ))
+        .unwrap();
+        assert_eq!(
+            serde_json::to_value(&node_context).unwrap()["schema"],
+            golden["node_context_schema"]
+        );
+        let mut unknown_field_context = serde_json::to_value(&node_context).unwrap();
+        unknown_field_context.as_object_mut().unwrap().insert(
+            "ignored_selected_chain_fact".to_string(),
+            serde_json::json!(true),
+        );
+        assert!(matches!(
+            store.export_node_da_object_v2_json(
+                &network,
+                &fixture.escrow,
+                &serde_json::to_string(&unknown_field_context).unwrap(),
+            ),
+            Err(LifecycleError::InvalidNodeDaContext("JSON/schema"))
+        ));
+        let node_bridge: serde_json::Value = serde_json::from_str(
+            &store
+                .export_node_da_object_v2_json(
+                    &network,
+                    &fixture.escrow,
+                    &serde_json::to_string(&node_context).unwrap(),
+                )
+                .unwrap(),
+        )
+        .unwrap();
+        assert_eq!(
+            node_bridge["schema"],
+            "misaka.palw.lifecycle-receipt-v3-node-da-bridge.v2"
+        );
+        assert_eq!(node_bridge["da"]["object_version"], 2);
+        assert_eq!(node_bridge["da"]["object_len"], golden["object_len"]);
+        assert_eq!(node_bridge["da"]["node_da_object_compatible"], true);
+        assert_eq!(node_bridge["enforcement"]["node_admission_required"], true);
+        assert_eq!(node_bridge["da"]["root"], golden["root"]);
+        assert_eq!(
+            node_bridge["bridge_object"]["bytes_hex"]
+                .as_str()
+                .unwrap()
+                .len(),
+            usize::try_from(golden["object_len"].as_u64().unwrap()).unwrap() * 2,
+            "outer canonical bytes are reusable as node admission hex"
+        );
+
+        let (prepare, command_id) = prepare_settlement(&mut store, &key, &fixture, 20);
+        assert_eq!(
+            store
+                .escrow_status(&network, &fixture.escrow)
+                .unwrap()
+                .state,
+            LifecycleEscrowState::SettlementPrepared
+        );
+        assert!(store
+            .escrow_status(&network, &fixture.escrow)
+            .unwrap()
+            .terminal_confirmation_id
+            .is_none());
+        assert!(!store.apply_event(&prepare, None).unwrap().newly_applied);
+        let confirmation = signed(
+            &key,
+            network,
+            32,
+            7,
+            21,
+            LifecycleEventPayloadV1::SettlementConfirmed {
+                escrow_id: fixture.escrow,
+                command_id,
+                rail_confirmation_id: h(0xd1),
+            },
+        );
+        assert!(
+            store
+                .apply_event(&confirmation, None)
+                .unwrap()
+                .newly_applied
+        );
+        assert!(
+            !store
+                .apply_event(&confirmation, None)
+                .unwrap()
+                .newly_applied
+        );
+        assert!(matches!(
+            store.apply_event(&prepare, None),
+            Err(LifecycleError::ReplayAfterAdvance)
+        ));
+        drop(store);
+        let store = LifecycleStore::open(&path).unwrap();
+        assert_eq!(
+            store
+                .escrow_status(&network, &fixture.escrow)
+                .unwrap()
+                .state,
+            LifecycleEscrowState::Settled
+        );
+        assert_eq!(fixture.asset, h(0x70));
+        assert_ne!(fixture.worker_0, fixture.worker_1);
+        assert_ne!(
+            fixture.submission_0.receipt.execution_nullifier,
+            fixture.submission_1.receipt.execution_nullifier
+        );
+    }
+
+    #[test]
+    fn tamper_and_same_network_nullifier_reuse_fail_closed_cross_network_is_allowed() {
+        let path = temp_db("nullifier");
+        let key = SigningKey::from_bytes(&[0x43; 32]);
+        let network_a = h(0x11);
+        let network_b = h(0x12);
+        let asset = h(0x70);
+        let worker_0 = verifying_key_and_credential_from_seed(&[0x11; 32]).1;
+        let worker_1 = verifying_key_and_credential_from_seed(&[0x22; 32]).1;
+        let mut store = LifecycleStore::open(&path).unwrap();
+        register(&mut store, &key, network_a);
+        register(&mut store, &key, network_b);
+        for (network, offset) in [(network_a, 1_u8), (network_b, 20_u8)] {
+            fund_bond(
+                &mut store,
+                &key,
+                network,
+                worker_0,
+                asset,
+                offset,
+                0xc0 + offset,
+                100,
+            );
+            fund_bond(
+                &mut store,
+                &key,
+                network,
+                worker_1,
+                asset,
+                offset + 1,
+                0xd0 + offset,
+                100,
+            );
+            create_assigned(
+                &mut store,
+                &key,
+                network,
+                h(0x20 + offset),
+                asset,
+                worker_0,
+                worker_1,
+                h(0x99),
+                h(0x31),
+                h(0x32),
+                offset + 2,
+            );
+        }
+        let fund = signed(
+            &key,
+            network_a,
+            1,
+            1,
+            50,
+            LifecycleEventPayloadV1::FundingConfirmed {
+                escrow_id: h(0x55),
+                requester_id: h(0xa0),
+                asset_id: asset,
+                amount: 100,
+                expires_epoch: 40,
+                funding_reference: h(0xee),
+            },
+        );
+        let mut tampered = fund.clone();
+        tampered.signature[0] ^= 1;
+        assert!(matches!(
+            store.apply_event(&tampered, None),
+            Err(LifecycleError::InvalidSignature)
+        ));
+        store.apply_event(&fund, None).unwrap();
+        let lock = signed(
+            &key,
+            network_a,
+            2,
+            2,
+            51,
+            LifecycleEventPayloadV1::EscrowLocked {
+                escrow_id: h(0x55),
+                amount: 100,
+            },
+        );
+        store.apply_event(&lock, None).unwrap();
+        let duplicate_job = signed(
+            &key,
+            network_a,
+            5,
+            3,
+            52,
+            LifecycleEventPayloadV1::Assigned {
+                escrow_id: h(0x55),
+                job_nullifier: h(0x99),
+                compute_set_id: h(0x31),
+                job_challenge: h(0x32),
+                issued_epoch: 5,
+                expires_epoch: 20,
+                worker_0,
+                worker_1,
+                bond_amount: 10,
+                fraud_window_end: 30,
+            },
+        );
+        assert!(matches!(
+            store.apply_event(&duplicate_job, None),
+            Err(LifecycleError::NullifierConsumed)
+        ));
+        let mut bytes = fund.canonical_bytes();
+        bytes.push(0);
+        assert!(matches!(
+            SignedLifecycleEventV1::decode_strict(&bytes),
+            Err(DecodeError::TrailingBytes)
+        ));
+    }
+
+    #[test]
+    fn external_references_are_single_use_across_funding_kinds() {
+        let path = temp_db("external-reference");
+        let key = SigningKey::from_bytes(&[0x53; 32]);
+        let network = h(0x15);
+        let reference = h(0xa5);
+        let mut store = LifecycleStore::open(&path).unwrap();
+        register(&mut store, &key, network);
+        let escrow_funding = signed(
+            &key,
+            network,
+            1,
+            1,
+            1,
+            LifecycleEventPayloadV1::FundingConfirmed {
+                escrow_id: h(0x66),
+                requester_id: h(0x67),
+                asset_id: h(0x70),
+                amount: 100,
+                expires_epoch: 40,
+                funding_reference: reference,
+            },
+        );
+        store.apply_event(&escrow_funding, None).unwrap();
+        let cross_kind_reuse = signed(
+            &key,
+            network,
+            1,
+            1,
+            2,
+            LifecycleEventPayloadV1::BondFunded {
+                worker_credential_id: h(0x68),
+                asset_id: h(0x70),
+                amount: 100,
+                funding_reference: reference,
+            },
+        );
+        assert!(matches!(
+            store.apply_event(&cross_kind_reuse, None),
+            Err(LifecycleError::ExternalReferenceConsumed)
+        ));
+    }
+
+    #[test]
+    fn concurrent_conflicting_double_settlement_has_one_winner() {
+        let path = temp_db("concurrent");
+        let key = SigningKey::from_bytes(&[0x44; 32]);
+        let network = h(0x13);
+        let fixture;
+        let command_id;
+        {
+            let mut store = LifecycleStore::open(&path).unwrap();
+            register(&mut store, &key, network);
+            fixture = create_ready(&mut store, &key, network, 60);
+            command_id = prepare_settlement(&mut store, &key, &fixture, 70).1;
+        }
+        let a = signed(
+            &key,
+            network,
+            32,
+            7,
+            71,
+            LifecycleEventPayloadV1::SettlementConfirmed {
+                escrow_id: fixture.escrow,
+                command_id,
+                rail_confirmation_id: h(0xe1),
+            },
+        );
+        let b = signed(
+            &key,
+            network,
+            32,
+            7,
+            72,
+            LifecycleEventPayloadV1::SettlementConfirmed {
+                escrow_id: fixture.escrow,
+                command_id,
+                rail_confirmation_id: h(0xe2),
+            },
+        );
+        let barrier = Arc::new(Barrier::new(3));
+        let handles: Vec<_> = [a, b]
+            .into_iter()
+            .map(|event| {
+                let path = path.clone();
+                let barrier = Arc::clone(&barrier);
+                std::thread::spawn(move || {
+                    let mut store = LifecycleStore::open(path).unwrap();
+                    barrier.wait();
+                    store.apply_event(&event, None)
+                })
+            })
+            .collect();
+        barrier.wait();
+        let results: Vec<_> = handles
+            .into_iter()
+            .map(|handle| handle.join().unwrap())
+            .collect();
+        assert_eq!(results.iter().filter(|result| result.is_ok()).count(), 1);
+        assert_eq!(results.iter().filter(|result| result.is_err()).count(), 1);
+        let store = LifecycleStore::open(&path).unwrap();
+        assert_eq!(
+            store
+                .escrow_status(&network, &fixture.escrow)
+                .unwrap()
+                .state,
+            LifecycleEscrowState::Settled
+        );
+    }
+
+    #[test]
+    fn slash_prepares_refund_and_unbond_waits_for_terminal_and_hold() {
+        let path = temp_db("slash");
+        let key = SigningKey::from_bytes(&[0x45; 32]);
+        let network = h(0x14);
+        let asset = h(0x70);
+        let worker_0 = verifying_key_and_credential_from_seed(&[0x11; 32]).1;
+        let worker_1 = verifying_key_and_credential_from_seed(&[0x22; 32]).1;
+        let escrow = h(0x61);
+        let mut store = LifecycleStore::open(&path).unwrap();
+        register(&mut store, &key, network);
+        fund_bond(&mut store, &key, network, worker_0, asset, 1, 0xb1, 100);
+        fund_bond(&mut store, &key, network, worker_1, asset, 2, 0xb2, 100);
+        create_assigned(
+            &mut store,
+            &key,
+            network,
+            escrow,
+            asset,
+            worker_0,
+            worker_1,
+            h(0x81),
+            h(0x31),
+            h(0x32),
+            3,
+        );
+        let slash = signed(
+            &key,
+            network,
+            10,
+            4,
+            10,
+            LifecycleEventPayloadV1::SlashFinalized {
+                escrow_id: escrow,
+                worker_credential_id: worker_0,
+                slash_id: h(0xf1),
+                amount: 10,
+                hold_until_epoch: 30,
+            },
+        );
+        let command = store
+            .apply_event(&slash, None)
+            .unwrap()
+            .payment_command_id
+            .unwrap();
+        assert_eq!(
+            store.escrow_status(&network, &escrow).unwrap().state,
+            LifecycleEscrowState::RefundPrepared
+        );
+        let refund = signed(
+            &key,
+            network,
+            11,
+            5,
+            11,
+            LifecycleEventPayloadV1::RefundConfirmed {
+                escrow_id: escrow,
+                command_id: command,
+                rail_confirmation_id: h(0xf2),
+            },
+        );
+        store.apply_event(&refund, None).unwrap();
+        let early_unbond = signed(
+            &key,
+            network,
+            30,
+            2,
+            12,
+            LifecycleEventPayloadV1::UnbondConfirmed {
+                worker_credential_id: worker_0,
+                asset_id: asset,
+                amount: 10,
+                rail_confirmation_id: h(0xf3),
+            },
+        );
+        assert!(matches!(
+            store.apply_event(&early_unbond, None),
+            Err(LifecycleError::BondGate)
+        ));
+        let late_unbond = signed(
+            &key,
+            network,
+            31,
+            2,
+            13,
+            LifecycleEventPayloadV1::UnbondConfirmed {
+                worker_credential_id: worker_0,
+                asset_id: asset,
+                amount: 10,
+                rail_confirmation_id: h(0xf4),
+            },
+        );
+        assert!(store.apply_event(&late_unbond, None).unwrap().newly_applied);
+    }
+
+    #[test]
+    fn refund_before_fraud_window_keeps_post_refund_slash_and_cross_kind_replay_closed() {
+        let path = temp_db("post-refund-slash");
+        let key = SigningKey::from_bytes(&[0x54; 32]);
+        let network = h(0x16);
+        let asset = h(0x70);
+        let worker_0 = verifying_key_and_credential_from_seed(&[0x11; 32]).1;
+        let worker_1 = verifying_key_and_credential_from_seed(&[0x22; 32]).1;
+        let escrow = h(0x71);
+        let mut store = LifecycleStore::open(&path).unwrap();
+        register(&mut store, &key, network);
+        fund_bond(&mut store, &key, network, worker_0, asset, 1, 0xb1, 100);
+        fund_bond(&mut store, &key, network, worker_1, asset, 2, 0xb2, 100);
+        create_assigned(
+            &mut store,
+            &key,
+            network,
+            escrow,
+            asset,
+            worker_0,
+            worker_1,
+            h(0x82),
+            h(0x31),
+            h(0x32),
+            3,
+        );
+        let timeout = signed(
+            &key,
+            network,
+            21,
+            4,
+            10,
+            LifecycleEventPayloadV1::TimeoutRefundPrepared {
+                escrow_id: escrow,
+                requester_amount: 100,
+            },
+        );
+        let command_id = store
+            .apply_event(&timeout, None)
+            .unwrap()
+            .payment_command_id
+            .unwrap();
+        let terminal_reference = h(0xf5);
+        let refund = signed(
+            &key,
+            network,
+            21,
+            5,
+            11,
+            LifecycleEventPayloadV1::RefundConfirmed {
+                escrow_id: escrow,
+                command_id,
+                rail_confirmation_id: terminal_reference,
+            },
+        );
+        store.apply_event(&refund, None).unwrap();
+        let slash = signed(
+            &key,
+            network,
+            25,
+            6,
+            12,
+            LifecycleEventPayloadV1::SlashFinalized {
+                escrow_id: escrow,
+                worker_credential_id: worker_0,
+                slash_id: h(0xf6),
+                amount: 10,
+                hold_until_epoch: 30,
+            },
+        );
+        let slash_outcome = store.apply_event(&slash, None).unwrap();
+        assert_eq!(slash_outcome.state, LifecycleEscrowState::Refunded as u8);
+        assert_eq!(slash_outcome.payment_command_id, Some(command_id));
+        let status = store.escrow_status(&network, &escrow).unwrap();
+        assert_eq!(status.state, LifecycleEscrowState::Refunded);
+        assert_eq!(status.sequence, 6);
+        assert_eq!(status.payment_command_id, Some(command_id));
+        assert_eq!(status.terminal_confirmation_id, Some(terminal_reference));
+
+        let reused_terminal_as_unbond = signed(
+            &key,
+            network,
+            31,
+            2,
+            13,
+            LifecycleEventPayloadV1::UnbondConfirmed {
+                worker_credential_id: worker_0,
+                asset_id: asset,
+                amount: 10,
+                rail_confirmation_id: terminal_reference,
+            },
+        );
+        assert!(matches!(
+            store.apply_event(&reused_terminal_as_unbond, None),
+            Err(LifecycleError::ExternalReferenceConsumed)
+        ));
+        let valid_unbond = signed(
+            &key,
+            network,
+            31,
+            2,
+            14,
+            LifecycleEventPayloadV1::UnbondConfirmed {
+                worker_credential_id: worker_0,
+                asset_id: asset,
+                amount: 10,
+                rail_confirmation_id: h(0xf7),
+            },
+        );
+        assert!(store.apply_event(&valid_unbond, None).is_ok());
+    }
+}
diff --git a/runtime-palw/src/receipt_v3.rs b/runtime-palw/src/receipt_v3.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3585d23e6b509ee491916be1041aba0abb83c2d3
--- /dev/null
+++ b/runtime-palw/src/receipt_v3.rs
@@ -0,0 +1,1247 @@
+//! Receipt v3 foundation — the node-owned conventions of the Receipt v3 breaking bundle
+//! (docs/adr-receipt-v3-node-ownership.md), implemented as the NEW consensus path.
+//!
+//! Ownership (frozen in the ADR): the node owns (1) signatures — ML-DSA-87 only; (2) Receipt v3
+//! keyed-BLAKE2b-512 / `Hash64` domains and fixed-width wire bytes; (3) the match predicate —
+//! `MatchProjectionV2` with `runtime_class_id` demoted to non-consensus telemetry; and (4) the
+//! selected-chain expectations required for admission. Runtime-local evidence-root domains remain
+//! runtime-owned. v1/v2 (Ed25519 / SHA3-256 / `Hash32` / `MatchProjectionV1`) are the
+//! calibration-era legacy stack and carry no v3 authority.
+//!
+//! The v3 verify path is **Ed25519-free by construction**: the envelope's only accepted algorithm
+//! tag is ML-DSA-87; there is no code path that accepts an Ed25519 signature here (the "provably-
+//! Ed25519-free mint binary" gate of ADR §1 — the same unrepresentable-bad-state pattern as
+//! `NoShowPenaltyDestination` having no `ToRequester`).
+
+use crate::receipt::ComputeReceiptV1;
+
+/// 64-byte consensus digest (ADR §2). Distinct from the legacy 32-byte `Hash32`.
+pub type Hash64 = [u8; 64];
+
+/// Receipt body schema version owned by the node contract.
+pub const RECEIPT_V3_VERSION: u16 = 3;
+/// ML-DSA-87 algorithm tag for the v3 signed envelope. Tag 0 (Ed25519) is NOT accepted in v3.
+pub const MLDSA87_ALGORITHM_ID: u8 = 1;
+/// ML-DSA-87 signature length (FIPS 204).
+pub const MLDSA87_SIGNATURE_LEN: usize = 4627;
+
+/// Keyed-hash domain for a canonical [`MatchProjectionV2`].
+pub const PALW_RECEIPT_V3_PROJECTION_DOMAIN: &[u8] = b"misaka-palw-v3/projection";
+/// Keyed-hash domain for the canonical receipt body that is signed.
+pub const PALW_RECEIPT_V3_SIGNING_DOMAIN: &[u8] = b"misaka-palw-v3/receipt-signing";
+/// Keyed-hash domain for receipt identity.
+pub const PALW_RECEIPT_V3_ID_DOMAIN: &[u8] = b"misaka-palw-v3/receipt-id";
+/// Keyed-hash domain for per-worker, per-job execution nullifiers.
+pub const PALW_RECEIPT_V3_EXECUTION_NULLIFIER_DOMAIN: &[u8] = b"misaka-palw-v3/execution-nullifier";
+/// Keyed-hash domain for canonical output-token commitments.
+pub const PALW_RECEIPT_V3_OUTPUT_DOMAIN: &[u8] = b"misaka-palw-v3/output";
+/// Keyed-hash domain for an order-independent matched-pair identity.
+pub const PALW_RECEIPT_V3_PAIR_DOMAIN: &[u8] = b"misaka-palw-v3/pair-id";
+/// ML-DSA-87 signature context for Receipt v3.
+pub const PALW_RECEIPT_V3_MLDSA87_CONTEXT: &[u8] = b"misaka-palw-v3/receipt/mldsa87";
+
+fn node_hash64(domain: &[u8], data: &[u8]) -> Hash64 {
+    let mut out = [0u8; 64];
+    out.copy_from_slice(
+        blake2b_simd::Params::new()
+            .hash_length(64)
+            .key(domain)
+            .to_state()
+            .update(data)
+            .finalize()
+            .as_bytes(),
+    );
+    out
+}
+
+/// Keyed BLAKE2b-512 with the domain tag as the key — byte-compatible with the node / public
+/// verifier primitive (`blake2b_512_keyed(context, data)`). This framed helper is retained only for
+/// legacy/testnet identifiers outside Receipt v3. Receipt v3 itself uses the node-owned fixed-width
+/// little-endian encodings below and never calls this helper.
+#[must_use]
+pub fn domain_hash64(domain: &str, schema_version: u16, parts: &[&[u8]]) -> Hash64 {
+    let mut data = Vec::new();
+    data.extend_from_slice(&schema_version.to_be_bytes());
+    for part in parts {
+        data.extend_from_slice(&(part.len() as u64).to_be_bytes());
+        data.extend_from_slice(part);
+    }
+    let mut out = [0u8; 64];
+    out.copy_from_slice(
+        blake2b_simd::Params::new()
+            .hash_length(64)
+            .key(domain.as_bytes())
+            .to_state()
+            .update(&data)
+            .finalize()
+            .as_bytes(),
+    );
+    out
+}
+
+/// Derive the node/provider-registry credential identity from the exact ML-DSA-87 verification
+/// key: unkeyed BLAKE2b-512, byte-compatible with the node's
+/// `validator_id_from_pubkey`. Receipt v3 verification binds this value to both identity fields.
+#[must_use]
+pub fn credential_id_from_verifying_key(verifying_key: &[u8]) -> Hash64 {
+    let mut out = [0u8; 64];
+    out.copy_from_slice(
+        blake2b_simd::Params::new()
+            .hash_length(64)
+            .to_state()
+            .update(verifying_key)
+            .finalize()
+            .as_bytes(),
+    );
+    out
+}
+
+/// Non-consensus implementation telemetry (ADR §3). `runtime_class_id` lives here in v3 — it is
+/// recorded for diagnostics but is NOT part of the match predicate, so bit-identical results from
+/// different hardware classes (the canonical-integer pool) can pair.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImplementationTelemetry {
+    /// Legacy runtime-class identity — diagnostics only, never matched (ADR §3).
+    pub runtime_class_id: [u8; 32],
+    /// Legacy runtime-manifest hash — diagnostics only.
+    pub runtime_manifest_hash: [u8; 32],
+}
+
+impl ImplementationTelemetry {
+    /// Fixed canonical telemetry length in the signed body.
+    pub const CANONICAL_LEN: usize = 64;
+
+    fn append_canonical(&self, out: &mut Vec<u8>) {
+        out.extend_from_slice(&self.runtime_class_id);
+        out.extend_from_slice(&self.runtime_manifest_hash);
+    }
+}
+
+/// The v3 exact-match projection (ADR §3 / node §8). Every field must be byte-equal between the
+/// two replicas. Deliberately EXCLUDED: `runtime_class_id` (telemetry), all per-worker identity
+/// fields. The name is V2 because reusing the V1 name for different semantics is forbidden.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MatchProjectionV2 {
+    /// Frozen job/model set identity.
+    pub compute_set_id: Hash64,
+    /// Fresh epoch-beacon challenge the execution was bound to.
+    pub job_challenge: Hash64,
+    /// Output (token) commitment — the class predicate core.
+    pub output_commitment: Hash64,
+    /// Canonical operation-schedule root.
+    pub schedule_root: Hash64,
+    /// Execution (trace/checkpoint) root.
+    pub execution_root: Hash64,
+    /// `MoE` expert-route root.
+    pub route_root: Hash64,
+    /// Recurrent-state root (hybrid models).
+    pub state_root: Hash64,
+    /// Semantic canonical compute units.
+    pub canonical_compute_units: u64,
+    /// Total token count (prefill + decode).
+    pub token_count: u64,
+    /// Canonical stop reason.
+    pub stop_reason: u8,
+}
+
+impl MatchProjectionV2 {
+    /// Fixed node-owned canonical encoding length.
+    pub const CANONICAL_LEN: usize = 7 * 64 + 8 + 8 + 1;
+
+    /// Fixed-width canonical bytes: declaration order, little-endian integers, no framing.
+    #[must_use]
+    pub fn canonical_bytes(&self) -> Vec<u8> {
+        let mut out = Vec::with_capacity(Self::CANONICAL_LEN);
+        for hash in [
+            &self.compute_set_id,
+            &self.job_challenge,
+            &self.output_commitment,
+            &self.schedule_root,
+            &self.execution_root,
+            &self.route_root,
+            &self.state_root,
+        ] {
+            out.extend_from_slice(hash);
+        }
+        out.extend_from_slice(&self.canonical_compute_units.to_le_bytes());
+        out.extend_from_slice(&self.token_count.to_le_bytes());
+        out.push(self.stop_reason);
+        debug_assert_eq!(out.len(), Self::CANONICAL_LEN);
+        out
+    }
+
+    /// Consensus digest of the projection under the node-owned domain.
+    #[must_use]
+    pub fn digest(&self) -> Hash64 {
+        node_hash64(PALW_RECEIPT_V3_PROJECTION_DOMAIN, &self.canonical_bytes())
+    }
+
+    /// First mismatching field name, or None if the pair matches (k=2 predicate).
+    #[must_use]
+    pub fn first_mismatch(&self, other: &Self) -> Option<&'static str> {
+        if self.compute_set_id != other.compute_set_id {
+            return Some("compute_set_id");
+        }
+        if self.job_challenge != other.job_challenge {
+            return Some("job_challenge");
+        }
+        if self.output_commitment != other.output_commitment {
+            return Some("output_commitment");
+        }
+        if self.schedule_root != other.schedule_root {
+            return Some("schedule_root");
+        }
+        if self.execution_root != other.execution_root {
+            return Some("execution_root");
+        }
+        if self.route_root != other.route_root {
+            return Some("route_root");
+        }
+        if self.state_root != other.state_root {
+            return Some("state_root");
+        }
+        if self.canonical_compute_units != other.canonical_compute_units {
+            return Some("canonical_compute_units");
+        }
+        if self.token_count != other.token_count {
+            return Some("token_count");
+        }
+        if self.stop_reason != other.stop_reason {
+            return Some("stop_reason");
+        }
+        None
+    }
+
+    /// Bridge from a calibration-era v1 receipt body: widens the legacy 32-byte commitments into
+    /// the v3 field slots (zero-padded — bridging only; native v3 issuance computes Hash64 直).
+    /// `runtime_class_id` is intentionally NOT read — it goes to `ImplementationTelemetry`.
+    #[must_use]
+    pub fn from_receipt_v1_bridge(r: &ComputeReceiptV1) -> (Self, ImplementationTelemetry) {
+        fn widen(h: &[u8; 32]) -> Hash64 {
+            let mut out = [0u8; 64];
+            out[..32].copy_from_slice(h);
+            out
+        }
+        (
+            Self {
+                compute_set_id: widen(&r.model_profile_id),
+                job_challenge: widen(&r.job_nullifier),
+                output_commitment: widen(&r.output_commitment),
+                schedule_root: widen(&r.operation_schedule_commitment),
+                execution_root: widen(&r.gemm_trace_root),
+                route_root: [0u8; 64],
+                state_root: [0u8; 64],
+                canonical_compute_units: r.canonical_compute_units,
+                token_count: u64::from(r.prefill_tokens) + u64::from(r.decode_tokens),
+                stop_reason: 0,
+            },
+            ImplementationTelemetry {
+                runtime_class_id: r.runtime_class_id,
+                runtime_manifest_hash: r.runtime_manifest_hash,
+            },
+        )
+    }
+}
+
+/// v3 signed envelope. The ONLY accepted algorithm is ML-DSA-87 — decoding any other tag fails
+/// closed, so an Ed25519 signature is unrepresentable on the v3 path.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SignedEnvelopeV3 {
+    /// Keyed-BLAKE2b-512 digest of the canonical v3 body.
+    pub body_digest: Hash64,
+    /// Signature algorithm tag — only [`MLDSA87_ALGORITHM_ID`] is valid.
+    pub algorithm: u8,
+    /// Registered credential identity of the signer (ADR §1: key = credential).
+    pub signer_credential_id: Hash64,
+    /// ML-DSA-87 signature bytes.
+    pub signature: Vec<u8>,
+}
+
+/// Node-supplied selected-chain expectations for one submitted receipt.
+///
+/// Supplying these values is mandatory for an admission decision. A worker-supplied receipt or
+/// verification key is never authoritative for any field in this structure.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ReceiptV3Expectations {
+    /// Expected network/genesis identity.
+    pub network_id: Hash64,
+    /// Expected registered compute set.
+    pub compute_set_id: Hash64,
+    /// Expected node-issued job challenge.
+    pub job_challenge: Hash64,
+    /// Expected replica slot (0 or 1).
+    pub replica_slot: u8,
+    /// Exact issue epoch of the assigned job.
+    pub issued_epoch: u64,
+    /// Exact expiry epoch of the assigned job.
+    pub expires_epoch: u64,
+    /// Node's current verification epoch.
+    pub current_epoch: u64,
+    /// Credential resolved independently from the active provider registry.
+    pub registered_credential_id: Hash64,
+}
+
+/// v3 envelope validation errors.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EnvelopeV3Error {
+    /// Algorithm tag is not ML-DSA-87 (this is where Ed25519 — tag 0 — is rejected).
+    UnsupportedAlgorithm(u8),
+    /// Signature length does not match ML-DSA-87.
+    SignatureLength(usize),
+}
+
+impl SignedEnvelopeV3 {
+    /// Structural validation — fail-closed on anything that is not an ML-DSA-87 envelope.
+    /// Cryptographic verification is performed by the `ml-dsa` backend (feature `ml-dsa`).
+    pub fn validate_structure(&self) -> Result<(), EnvelopeV3Error> {
+        if self.algorithm != MLDSA87_ALGORITHM_ID {
+            return Err(EnvelopeV3Error::UnsupportedAlgorithm(self.algorithm));
+        }
+        if self.signature.len() != MLDSA87_SIGNATURE_LEN {
+            return Err(EnvelopeV3Error::SignatureLength(self.signature.len()));
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn domain_separation_and_prefix_freedom() {
+        let a = domain_hash64("tag-a/v3", 3, &[b"ab", b"c"]);
+        let b = domain_hash64("tag-b/v3", 3, &[b"ab", b"c"]);
+        let c = domain_hash64("tag-a/v3", 3, &[b"a", b"bc"]);
+        assert_ne!(a, b, "different domain keys must differ");
+        assert_ne!(a, c, "length-prefix framing must be prefix-free");
+        assert_eq!(
+            a,
+            domain_hash64("tag-a/v3", 3, &[b"ab", b"c"]),
+            "deterministic"
+        );
+    }
+
+    #[test]
+    fn keyed_blake2b_matches_public_verifier_construction() {
+        // Same construction as the public conformance verifier / node:
+        // blake2b_simd::Params::new().hash_length(64).key(context).update(data)
+        let direct = blake2b_simd::Params::new()
+            .hash_length(64)
+            .key(b"palw-k1/file")
+            .to_state()
+            .update(b"hello")
+            .finalize();
+        let mut framed = Vec::new();
+        framed.extend_from_slice(&0u16.to_be_bytes());
+        framed.extend_from_slice(&(5u64).to_be_bytes());
+        framed.extend_from_slice(b"hello");
+        let ours = domain_hash64("palw-k1/file", 0, &[b"hello"]);
+        // ours frames the data; direct does not — assert the primitive is the same by re-deriving:
+        let expect = blake2b_simd::Params::new()
+            .hash_length(64)
+            .key(b"palw-k1/file")
+            .to_state()
+            .update(&framed)
+            .finalize();
+        assert_eq!(ours.as_slice(), expect.as_bytes());
+        assert_ne!(ours.as_slice(), direct.as_bytes());
+    }
+
+    fn sample_projection() -> MatchProjectionV2 {
+        MatchProjectionV2 {
+            compute_set_id: [1u8; 64],
+            job_challenge: [2u8; 64],
+            output_commitment: [3u8; 64],
+            schedule_root: [4u8; 64],
+            execution_root: [5u8; 64],
+            route_root: [6u8; 64],
+            state_root: [7u8; 64],
+            canonical_compute_units: 41692,
+            token_count: 10,
+            stop_reason: 0,
+        }
+    }
+
+    #[test]
+    fn v2_projection_matches_across_different_hardware_classes() {
+        // The defining V2 property: two replicas with byte-equal consensus fields MATCH even when
+        // their telemetry (runtime_class_id) differs — the cross-vendor single pool.
+        let a = sample_projection();
+        let b = sample_projection();
+        let ta = ImplementationTelemetry {
+            runtime_class_id: [0xAA; 32],
+            runtime_manifest_hash: [1; 32],
+        };
+        let tb = ImplementationTelemetry {
+            runtime_class_id: [0xBB; 32],
+            runtime_manifest_hash: [2; 32],
+        };
+        assert_ne!(ta, tb);
+        assert_eq!(
+            a.first_mismatch(&b),
+            None,
+            "telemetry must not affect the match"
+        );
+        assert_eq!(a.digest(), b.digest());
+    }
+
+    #[test]
+    fn v2_projection_rejects_consensus_field_divergence() {
+        let a = sample_projection();
+        let mut b = sample_projection();
+        b.output_commitment = [9u8; 64];
+        assert_eq!(a.first_mismatch(&b), Some("output_commitment"));
+        assert_ne!(a.digest(), b.digest());
+        let mut c = sample_projection();
+        c.canonical_compute_units += 1;
+        assert_eq!(a.first_mismatch(&c), Some("canonical_compute_units"));
+    }
+
+    #[test]
+    fn v3_envelope_is_ed25519_free_by_construction() {
+        let env = SignedEnvelopeV3 {
+            body_digest: [0u8; 64],
+            algorithm: 0, // Ed25519's legacy tag
+            signer_credential_id: [0u8; 64],
+            signature: vec![0u8; 64],
+        };
+        assert_eq!(
+            env.validate_structure(),
+            Err(EnvelopeV3Error::UnsupportedAlgorithm(0))
+        );
+        let bad_len = SignedEnvelopeV3 {
+            algorithm: MLDSA87_ALGORITHM_ID,
+            ..env.clone()
+        };
+        assert_eq!(
+            bad_len.validate_structure(),
+            Err(EnvelopeV3Error::SignatureLength(64))
+        );
+        let ok = SignedEnvelopeV3 {
+            algorithm: MLDSA87_ALGORITHM_ID,
+            signature: vec![0u8; MLDSA87_SIGNATURE_LEN],
+            ..env
+        };
+        assert_eq!(ok.validate_structure(), Ok(()));
+    }
+}
+
+/// ML-DSA-87 verifying-key length (FIPS 204).
+pub const MLDSA87_VERIFYING_KEY_LEN: usize = 2592;
+
+/// The v3 receipt body — the new leaf of the breaking bundle (ADR §4). All consensus digests are
+/// `Hash64`; the projection IS the consensus content; telemetry is carried but never matched.
+/// Domain tags and fixed-width encodings mirror the node-owned Receipt v3 wire contract.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ComputeReceiptV3 {
+    /// Receipt schema version (3).
+    pub receipt_version: u16,
+    /// Network identity (testnet/mainnet separation).
+    pub network_id: Hash64,
+    /// Consensus projection (the exact-match set).
+    pub projection: MatchProjectionV2,
+    /// Non-consensus diagnostics.
+    pub telemetry: ImplementationTelemetry,
+    /// Persistent registered credential of the worker (ADR §1: signing key = credential key).
+    pub worker_credential_id: Hash64,
+    /// Node-assigned replica slot. Receipt v3 accepts only 0 or 1.
+    pub replica_slot: u8,
+    /// Per-execution nullifier (double-count prevention).
+    pub execution_nullifier: Hash64,
+    /// Issue epoch.
+    pub issued_epoch: u64,
+    /// Expiry epoch.
+    pub expires_epoch: u64,
+}
+
+impl ComputeReceiptV3 {
+    /// Fixed canonical node-owned body length.
+    pub const CANONICAL_LEN: usize = 2
+        + 64
+        + MatchProjectionV2::CANONICAL_LEN
+        + ImplementationTelemetry::CANONICAL_LEN
+        + 64
+        + 1
+        + 64
+        + 8
+        + 8;
+
+    /// Fixed-width canonical body bytes signed by the worker.
+    #[must_use]
+    pub fn canonical_bytes(&self) -> Vec<u8> {
+        let mut out = Vec::with_capacity(Self::CANONICAL_LEN);
+        out.extend_from_slice(&self.receipt_version.to_le_bytes());
+        out.extend_from_slice(&self.network_id);
+        out.extend_from_slice(&self.projection.canonical_bytes());
+        self.telemetry.append_canonical(&mut out);
+        out.extend_from_slice(&self.worker_credential_id);
+        out.push(self.replica_slot);
+        out.extend_from_slice(&self.execution_nullifier);
+        out.extend_from_slice(&self.issued_epoch.to_le_bytes());
+        out.extend_from_slice(&self.expires_epoch.to_le_bytes());
+        debug_assert_eq!(out.len(), Self::CANONICAL_LEN);
+        out
+    }
+
+    /// Canonical signing digest over the full node-owned body.
+    #[must_use]
+    pub fn signing_digest(&self) -> Hash64 {
+        node_hash64(PALW_RECEIPT_V3_SIGNING_DOMAIN, &self.canonical_bytes())
+    }
+
+    /// Receipt identity.
+    #[must_use]
+    pub fn receipt_id(&self) -> Hash64 {
+        node_hash64(PALW_RECEIPT_V3_ID_DOMAIN, &self.signing_digest())
+    }
+}
+
+/// Derive the only valid execution nullifier for a worker's assigned slot and job.
+#[must_use]
+pub fn execution_nullifier_v3(
+    network_id: &Hash64,
+    compute_set_id: &Hash64,
+    job_challenge: &Hash64,
+    worker_credential_id: &Hash64,
+    replica_slot: u8,
+    issued_epoch: u64,
+) -> Hash64 {
+    let mut preimage = Vec::with_capacity(2 + 4 * 64 + 1 + 8);
+    preimage.extend_from_slice(&RECEIPT_V3_VERSION.to_le_bytes());
+    for hash in [
+        network_id,
+        compute_set_id,
+        job_challenge,
+        worker_credential_id,
+    ] {
+        preimage.extend_from_slice(hash);
+    }
+    preimage.push(replica_slot);
+    preimage.extend_from_slice(&issued_epoch.to_le_bytes());
+    node_hash64(PALW_RECEIPT_V3_EXECUTION_NULLIFIER_DOMAIN, &preimage)
+}
+
+/// Commit a node-issued challenge and a canonical `u32` token-id sequence.
+#[must_use]
+pub fn output_commitment_v3(tokens: &[u32], job_challenge: &Hash64) -> Hash64 {
+    let mut preimage = Vec::with_capacity(2 + 64 + 8 + tokens.len() * 4);
+    preimage.extend_from_slice(&RECEIPT_V3_VERSION.to_le_bytes());
+    preimage.extend_from_slice(job_challenge);
+    preimage.extend_from_slice(&(tokens.len() as u64).to_le_bytes());
+    for token in tokens {
+        preimage.extend_from_slice(&token.to_le_bytes());
+    }
+    node_hash64(PALW_RECEIPT_V3_OUTPUT_DOMAIN, &preimage)
+}
+
+/// A matched v3 replica pair (k=2 verdict).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MatchedPairV3 {
+    /// Deterministic pair identity (order-independent).
+    pub pair_id: Hash64,
+}
+
+/// v3 k=2 match errors.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum MatchV3Error {
+    /// Either body is not Receipt v3.
+    ReceiptVersion,
+    /// Networks differ.
+    NetworkMismatch,
+    /// Validity windows differ.
+    EpochWindowMismatch,
+    /// A slot is outside the closed set {0, 1}.
+    InvalidReplicaSlot(u8),
+    /// The two receipts are not from independent workers.
+    NotIndependent(&'static str),
+    /// A consensus projection field diverged.
+    ProjectionMismatch(&'static str),
+}
+
+/// Low-level v3 k=2 body predicate: same network, independent workers, byte-equal projections.
+///
+/// This function performs no signature, registry, selected-chain job, or current-epoch checks and
+/// therefore MUST NOT be treated as an admission or value-settlement verdict. Admission callers
+/// must first verify both bodies against independent [`ReceiptV3Expectations`].
+/// `runtime_class_id` is deliberately never consulted — cross-vendor pairs are valid (ADR §3).
+pub fn match_pair_v3(
+    a: &ComputeReceiptV3,
+    b: &ComputeReceiptV3,
+) -> Result<MatchedPairV3, MatchV3Error> {
+    if a.receipt_version != RECEIPT_V3_VERSION || b.receipt_version != RECEIPT_V3_VERSION {
+        return Err(MatchV3Error::ReceiptVersion);
+    }
+    if a.network_id != b.network_id {
+        return Err(MatchV3Error::NetworkMismatch);
+    }
+    if a.issued_epoch != b.issued_epoch || a.expires_epoch != b.expires_epoch {
+        return Err(MatchV3Error::EpochWindowMismatch);
+    }
+    if a.replica_slot > 1 {
+        return Err(MatchV3Error::InvalidReplicaSlot(a.replica_slot));
+    }
+    if b.replica_slot > 1 {
+        return Err(MatchV3Error::InvalidReplicaSlot(b.replica_slot));
+    }
+    if a.replica_slot == b.replica_slot {
+        return Err(MatchV3Error::NotIndependent("replica_slot"));
+    }
+    if a.worker_credential_id == b.worker_credential_id {
+        return Err(MatchV3Error::NotIndependent("worker_credential_id"));
+    }
+    if a.execution_nullifier == b.execution_nullifier {
+        return Err(MatchV3Error::NotIndependent("execution_nullifier"));
+    }
+    if let Some(field) = a.projection.first_mismatch(&b.projection) {
+        return Err(MatchV3Error::ProjectionMismatch(field));
+    }
+    let a_tuple = (a.worker_credential_id, a.execution_nullifier);
+    let b_tuple = (b.worker_credential_id, b.execution_nullifier);
+    let (lo, hi) = if a_tuple <= b_tuple {
+        (a_tuple, b_tuple)
+    } else {
+        (b_tuple, a_tuple)
+    };
+    let mut preimage = Vec::with_capacity(MatchProjectionV2::CANONICAL_LEN + 4 * 64);
+    preimage.extend_from_slice(&a.projection.digest());
+    for hash in [&lo.0, &lo.1, &hi.0, &hi.1] {
+        preimage.extend_from_slice(hash);
+    }
+    Ok(MatchedPairV3 {
+        pair_id: node_hash64(PALW_RECEIPT_V3_PAIR_DOMAIN, &preimage),
+    })
+}
+
+/// ML-DSA-87 signing/verification backend (feature `ml-dsa`). The seed-based API keeps issuance
+/// deterministic for tests; production keys come from the registered credential (ADR §1).
+#[cfg(feature = "ml-dsa")]
+pub mod mldsa {
+    use super::{
+        credential_id_from_verifying_key, execution_nullifier_v3, ComputeReceiptV3,
+        EnvelopeV3Error, Hash64, ReceiptV3Expectations, SignedEnvelopeV3, MLDSA87_ALGORITHM_ID,
+        MLDSA87_SIGNATURE_LEN, MLDSA87_VERIFYING_KEY_LEN, PALW_RECEIPT_V3_MLDSA87_CONTEXT,
+        RECEIPT_V3_VERSION,
+    };
+    use ml_dsa::{
+        EncodedSignature, EncodedVerifyingKey, ExpandedSigningKey, MlDsa87, Signature, VerifyingKey,
+    };
+
+    /// Errors for the ML-DSA v3 flow.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub enum MlDsaV3Error {
+        /// Envelope structure invalid (wrong algorithm / lengths).
+        Envelope(EnvelopeV3Error),
+        /// Signature bytes failed to decode.
+        SignatureDecode,
+        /// Verifying key bytes have the wrong length.
+        VerifyingKeyLength(usize),
+        /// The envelope digest does not match the receipt body.
+        DigestMismatch,
+        /// Receipt version was not v3.
+        ReceiptVersion(u16),
+        /// Receipt slot was outside the closed set {0, 1}.
+        InvalidReplicaSlot(u8),
+        /// Receipt slot did not equal the selected-chain assignment.
+        ReplicaSlotMismatch,
+        /// Receipt network did not equal the selected-chain network.
+        NetworkMismatch,
+        /// Receipt compute set did not equal the registered expected set.
+        ComputeSetMismatch,
+        /// Receipt challenge did not equal the node-issued job challenge.
+        JobChallengeMismatch,
+        /// Receipt issue epoch did not equal the assigned job issue epoch.
+        IssuedEpochMismatch,
+        /// Receipt expiry epoch did not equal the assigned job expiry epoch.
+        ExpiresEpochMismatch,
+        /// Receipt issue/expiry epochs were inverted.
+        InvalidEpochWindow,
+        /// Receipt is not valid yet at the selected-chain current epoch.
+        NotYetValid,
+        /// Receipt has expired at the selected-chain current epoch.
+        Expired,
+        /// Verification-key identity was not independently registered in selected-chain state.
+        UnregisteredCredential,
+        /// Receipt nullifier did not equal the node-owned re-derivation.
+        ExecutionNullifierMismatch,
+        /// Caller-supplied signer identity did not derive from the signing key.
+        SignerCredentialMismatch,
+        /// Envelope signer identity did not derive from the verification key.
+        EnvelopeCredentialMismatch,
+        /// Receipt worker identity did not derive from the verification key.
+        ReceiptCredentialMismatch,
+        /// Cryptographic verification failed.
+        SignatureInvalid,
+        /// Signing failed.
+        SigningFailed,
+    }
+
+    /// Sign a v3 receipt with an ML-DSA-87 key derived from `seed` (deterministic signing mode).
+    pub fn sign_receipt_v3(
+        receipt: &ComputeReceiptV3,
+        seed: &[u8; 32],
+        signer_credential_id: Hash64,
+    ) -> Result<(SignedEnvelopeV3, Vec<u8>), MlDsaV3Error> {
+        if receipt.receipt_version != RECEIPT_V3_VERSION {
+            return Err(MlDsaV3Error::ReceiptVersion(receipt.receipt_version));
+        }
+        if receipt.replica_slot > 1 {
+            return Err(MlDsaV3Error::InvalidReplicaSlot(receipt.replica_slot));
+        }
+        if receipt.issued_epoch > receipt.expires_epoch {
+            return Err(MlDsaV3Error::InvalidEpochWindow);
+        }
+        let expected_nullifier = execution_nullifier_v3(
+            &receipt.network_id,
+            &receipt.projection.compute_set_id,
+            &receipt.projection.job_challenge,
+            &receipt.worker_credential_id,
+            receipt.replica_slot,
+            receipt.issued_epoch,
+        );
+        if receipt.execution_nullifier != expected_nullifier {
+            return Err(MlDsaV3Error::ExecutionNullifierMismatch);
+        }
+        let sk = ExpandedSigningKey::<MlDsa87>::from_seed(&(*seed).into());
+        let vk_bytes = sk.verifying_key().encode().to_vec();
+        let derived_credential = credential_id_from_verifying_key(&vk_bytes);
+        if signer_credential_id != derived_credential
+            || receipt.worker_credential_id != derived_credential
+        {
+            return Err(MlDsaV3Error::SignerCredentialMismatch);
+        }
+        let digest = receipt.signing_digest();
+        let sig = sk
+            .sign_deterministic(&digest, PALW_RECEIPT_V3_MLDSA87_CONTEXT)
+            .map_err(|_| MlDsaV3Error::SigningFailed)?;
+        let envelope = SignedEnvelopeV3 {
+            body_digest: digest,
+            algorithm: MLDSA87_ALGORITHM_ID,
+            signer_credential_id,
+            signature: sig.encode().to_vec(),
+        };
+        debug_assert_eq!(envelope.signature.len(), MLDSA87_SIGNATURE_LEN);
+        debug_assert_eq!(vk_bytes.len(), MLDSA87_VERIFYING_KEY_LEN);
+        Ok((envelope, vk_bytes))
+    }
+
+    /// Derive the public verification key and its node-registry credential id from a signing seed.
+    #[must_use]
+    pub fn verifying_key_and_credential_from_seed(seed: &[u8; 32]) -> (Vec<u8>, Hash64) {
+        let sk = ExpandedSigningKey::<MlDsa87>::from_seed(&(*seed).into());
+        let verifying_key = sk.verifying_key().encode().to_vec();
+        let credential = credential_id_from_verifying_key(&verifying_key);
+        (verifying_key, credential)
+    }
+
+    fn verify_receipt_v3_inner(
+        receipt: &ComputeReceiptV3,
+        envelope: &SignedEnvelopeV3,
+        verifying_key: &[u8],
+        expected: Option<&ReceiptV3Expectations>,
+    ) -> Result<(), MlDsaV3Error> {
+        envelope
+            .validate_structure()
+            .map_err(MlDsaV3Error::Envelope)?;
+        if verifying_key.len() != MLDSA87_VERIFYING_KEY_LEN {
+            return Err(MlDsaV3Error::VerifyingKeyLength(verifying_key.len()));
+        }
+        if receipt.receipt_version != RECEIPT_V3_VERSION {
+            return Err(MlDsaV3Error::ReceiptVersion(receipt.receipt_version));
+        }
+        if receipt.replica_slot > 1 {
+            return Err(MlDsaV3Error::InvalidReplicaSlot(receipt.replica_slot));
+        }
+        if let Some(expected) = expected {
+            if receipt.replica_slot != expected.replica_slot {
+                return Err(MlDsaV3Error::ReplicaSlotMismatch);
+            }
+            if receipt.network_id != expected.network_id {
+                return Err(MlDsaV3Error::NetworkMismatch);
+            }
+            if receipt.projection.compute_set_id != expected.compute_set_id {
+                return Err(MlDsaV3Error::ComputeSetMismatch);
+            }
+            if receipt.projection.job_challenge != expected.job_challenge {
+                return Err(MlDsaV3Error::JobChallengeMismatch);
+            }
+            if receipt.issued_epoch != expected.issued_epoch {
+                return Err(MlDsaV3Error::IssuedEpochMismatch);
+            }
+            if receipt.expires_epoch != expected.expires_epoch {
+                return Err(MlDsaV3Error::ExpiresEpochMismatch);
+            }
+        }
+        if receipt.issued_epoch > receipt.expires_epoch {
+            return Err(MlDsaV3Error::InvalidEpochWindow);
+        }
+        if let Some(expected) = expected {
+            if expected.current_epoch < receipt.issued_epoch {
+                return Err(MlDsaV3Error::NotYetValid);
+            }
+            if expected.current_epoch > receipt.expires_epoch {
+                return Err(MlDsaV3Error::Expired);
+            }
+        }
+        let derived_credential = credential_id_from_verifying_key(verifying_key);
+        if expected.is_some_and(|value| derived_credential != value.registered_credential_id) {
+            return Err(MlDsaV3Error::UnregisteredCredential);
+        }
+        if envelope.signer_credential_id != derived_credential {
+            return Err(MlDsaV3Error::EnvelopeCredentialMismatch);
+        }
+        if receipt.worker_credential_id != derived_credential {
+            return Err(MlDsaV3Error::ReceiptCredentialMismatch);
+        }
+        let expected_nullifier = execution_nullifier_v3(
+            &receipt.network_id,
+            &receipt.projection.compute_set_id,
+            &receipt.projection.job_challenge,
+            &receipt.worker_credential_id,
+            receipt.replica_slot,
+            receipt.issued_epoch,
+        );
+        if receipt.execution_nullifier != expected_nullifier {
+            return Err(MlDsaV3Error::ExecutionNullifierMismatch);
+        }
+        if envelope.body_digest != receipt.signing_digest() {
+            return Err(MlDsaV3Error::DigestMismatch);
+        }
+        let enc_vk = EncodedVerifyingKey::<MlDsa87>::try_from(verifying_key)
+            .map_err(|_| MlDsaV3Error::VerifyingKeyLength(verifying_key.len()))?;
+        let vk = VerifyingKey::<MlDsa87>::decode(&enc_vk);
+        let enc_sig = EncodedSignature::<MlDsa87>::try_from(envelope.signature.as_slice())
+            .map_err(|_| MlDsaV3Error::SignatureDecode)?;
+        let sig = Signature::<MlDsa87>::decode(&enc_sig).ok_or(MlDsaV3Error::SignatureDecode)?;
+        if vk.verify_with_context(&envelope.body_digest, PALW_RECEIPT_V3_MLDSA87_CONTEXT, &sig) {
+            Ok(())
+        } else {
+            Err(MlDsaV3Error::SignatureInvalid)
+        }
+    }
+
+    /// Verify a v3 receipt cryptographically and structurally without making an admission decision.
+    ///
+    /// This is suitable for worker self-checks and offline artifact inspection. Because it has no
+    /// selected-chain job, epoch, or registry inputs, success MUST NOT be interpreted as network
+    /// admission or value-settlement eligibility.
+    pub fn verify_receipt_v3_self_consistent(
+        receipt: &ComputeReceiptV3,
+        envelope: &SignedEnvelopeV3,
+        verifying_key: &[u8],
+    ) -> Result<(), MlDsaV3Error> {
+        verify_receipt_v3_inner(receipt, envelope, verifying_key, None)
+    }
+
+    /// Verify a v3 receipt against selected-chain job, epoch, network, and registry expectations.
+    /// Every identity edge is checked explicitly:
+    /// `hash(vk) == registered == envelope.signer == receipt.worker`.
+    pub fn verify_receipt_v3(
+        receipt: &ComputeReceiptV3,
+        envelope: &SignedEnvelopeV3,
+        verifying_key: &[u8],
+        expected: &ReceiptV3Expectations,
+    ) -> Result<(), MlDsaV3Error> {
+        verify_receipt_v3_inner(receipt, envelope, verifying_key, Some(expected))
+    }
+}
+
+#[cfg(all(test, feature = "ml-dsa"))]
+mod mldsa_tests {
+    use super::mldsa::{
+        sign_receipt_v3, verify_receipt_v3, verify_receipt_v3_self_consistent,
+        verifying_key_and_credential_from_seed, MlDsaV3Error,
+    };
+    use super::*;
+
+    fn receipt(worker_credential_id: Hash64, replica_slot: u8, class: u8) -> ComputeReceiptV3 {
+        let mut receipt = ComputeReceiptV3 {
+            receipt_version: RECEIPT_V3_VERSION,
+            network_id: [7u8; 64],
+            projection: MatchProjectionV2 {
+                compute_set_id: [1u8; 64],
+                job_challenge: [2u8; 64],
+                output_commitment: [3u8; 64],
+                schedule_root: [4u8; 64],
+                execution_root: [5u8; 64],
+                route_root: [6u8; 64],
+                state_root: [8u8; 64],
+                canonical_compute_units: 41692,
+                token_count: 10,
+                stop_reason: 0,
+            },
+            telemetry: ImplementationTelemetry {
+                runtime_class_id: [class; 32],
+                runtime_manifest_hash: [class; 32],
+            },
+            worker_credential_id,
+            replica_slot,
+            execution_nullifier: [0; 64],
+            issued_epoch: 1,
+            expires_epoch: 100,
+        };
+        receipt.execution_nullifier = execution_nullifier_v3(
+            &receipt.network_id,
+            &receipt.projection.compute_set_id,
+            &receipt.projection.job_challenge,
+            &receipt.worker_credential_id,
+            receipt.replica_slot,
+            receipt.issued_epoch,
+        );
+        receipt
+    }
+
+    fn expectations(receipt: &ComputeReceiptV3) -> ReceiptV3Expectations {
+        ReceiptV3Expectations {
+            network_id: receipt.network_id,
+            compute_set_id: receipt.projection.compute_set_id,
+            job_challenge: receipt.projection.job_challenge,
+            replica_slot: receipt.replica_slot,
+            issued_epoch: receipt.issued_epoch,
+            expires_epoch: receipt.expires_epoch,
+            current_epoch: receipt.issued_epoch,
+            registered_credential_id: receipt.worker_credential_id,
+        }
+    }
+
+    #[test]
+    fn v3_end_to_end_sign_verify_and_cross_vendor_k2_match() {
+        // Two independent workers on DIFFERENT hardware classes (telemetry differs) execute the
+        // same job: both ML-DSA-87 receipts verify, and the k=2 match ACCEPTS the pair.
+        let (_, credential_a) = verifying_key_and_credential_from_seed(&[1u8; 32]);
+        let (_, credential_b) = verifying_key_and_credential_from_seed(&[2u8; 32]);
+        let ra = receipt(credential_a, 0, 0xAA);
+        let rb = receipt(credential_b, 1, 0xBB);
+        let (ea, vka) = sign_receipt_v3(&ra, &[1u8; 32], credential_a).unwrap();
+        let (eb, vkb) = sign_receipt_v3(&rb, &[2u8; 32], credential_b).unwrap();
+        assert_eq!(ea.signature.len(), MLDSA87_SIGNATURE_LEN);
+        verify_receipt_v3(&ra, &ea, &vka, &expectations(&ra)).unwrap();
+        verify_receipt_v3(&rb, &eb, &vkb, &expectations(&rb)).unwrap();
+        let pair = match_pair_v3(&ra, &rb).unwrap();
+        let pair_rev = match_pair_v3(&rb, &ra).unwrap();
+        assert_eq!(
+            pair.pair_id, pair_rev.pair_id,
+            "pair id is order-independent"
+        );
+    }
+
+    #[test]
+    fn v3_verify_rejects_tamper_wrong_key_and_self_pair() {
+        let (_, credential_a) = verifying_key_and_credential_from_seed(&[1u8; 32]);
+        let ra = receipt(credential_a, 0, 0xAA);
+        let (ea, vka) = sign_receipt_v3(&ra, &[1u8; 32], credential_a).unwrap();
+        // tampered body
+        let mut tampered = ra.clone();
+        tampered.projection.output_commitment = [9u8; 64];
+        assert_eq!(
+            verify_receipt_v3_self_consistent(&tampered, &ea, &vka),
+            Err(MlDsaV3Error::DigestMismatch)
+        );
+        // wrong key
+        let (vk_other, _) = verifying_key_and_credential_from_seed(&[3u8; 32]);
+        assert_eq!(
+            verify_receipt_v3_self_consistent(&ra, &ea, &vk_other),
+            Err(MlDsaV3Error::EnvelopeCredentialMismatch)
+        );
+        // The signer cannot claim an arbitrary credential for this key.
+        assert_eq!(
+            sign_receipt_v3(&ra, &[1u8; 32], [0xFE; 64]),
+            Err(MlDsaV3Error::SignerCredentialMismatch)
+        );
+        // Both duplicated credential fields are independently bound to hash(verifying_key).
+        let mut forged_envelope = ea.clone();
+        forged_envelope.signer_credential_id = [0xFE; 64];
+        assert_eq!(
+            verify_receipt_v3_self_consistent(&ra, &forged_envelope, &vka),
+            Err(MlDsaV3Error::EnvelopeCredentialMismatch)
+        );
+        let mut forged_receipt = ra.clone();
+        forged_receipt.worker_credential_id = [0xFE; 64];
+        assert_eq!(
+            verify_receipt_v3_self_consistent(&forged_receipt, &ea, &vka),
+            Err(MlDsaV3Error::ReceiptCredentialMismatch)
+        );
+        // self-pair (same credential) rejected
+        let rb = receipt(credential_a, 1, 0xBB);
+        assert_eq!(
+            match_pair_v3(&ra, &rb),
+            Err(MatchV3Error::NotIndependent("worker_credential_id"))
+        );
+        // diverged output rejected
+        let (_, credential_c) = verifying_key_and_credential_from_seed(&[3u8; 32]);
+        let mut rc = receipt(credential_c, 1, 0xCC);
+        rc.projection.output_commitment = [9u8; 64];
+        assert_eq!(
+            match_pair_v3(&ra, &rc),
+            Err(MatchV3Error::ProjectionMismatch("output_commitment"))
+        );
+
+        // A cryptographically valid self-generated key is not an admitted registry credential.
+        let mut unregistered = expectations(&ra);
+        unregistered.registered_credential_id = [0xFD; 64];
+        assert_eq!(
+            verify_receipt_v3(&ra, &ea, &vka, &unregistered),
+            Err(MlDsaV3Error::UnregisteredCredential)
+        );
+    }
+
+    #[test]
+    fn v3_admission_requires_every_selected_chain_expectation() {
+        let (_, credential) = verifying_key_and_credential_from_seed(&[1u8; 32]);
+        let receipt = receipt(credential, 0, 0xAA);
+        let (envelope, verifying_key) = sign_receipt_v3(&receipt, &[1u8; 32], credential).unwrap();
+        let expected = expectations(&receipt);
+        let cases = [
+            (
+                ReceiptV3Expectations {
+                    network_id: [0xF0; 64],
+                    ..expected.clone()
+                },
+                MlDsaV3Error::NetworkMismatch,
+            ),
+            (
+                ReceiptV3Expectations {
+                    compute_set_id: [0xF1; 64],
+                    ..expected.clone()
+                },
+                MlDsaV3Error::ComputeSetMismatch,
+            ),
+            (
+                ReceiptV3Expectations {
+                    job_challenge: [0xF2; 64],
+                    ..expected.clone()
+                },
+                MlDsaV3Error::JobChallengeMismatch,
+            ),
+            (
+                ReceiptV3Expectations {
+                    replica_slot: 1,
+                    ..expected.clone()
+                },
+                MlDsaV3Error::ReplicaSlotMismatch,
+            ),
+            (
+                ReceiptV3Expectations {
+                    issued_epoch: 2,
+                    ..expected.clone()
+                },
+                MlDsaV3Error::IssuedEpochMismatch,
+            ),
+            (
+                ReceiptV3Expectations {
+                    expires_epoch: 99,
+                    ..expected.clone()
+                },
+                MlDsaV3Error::ExpiresEpochMismatch,
+            ),
+            (
+                ReceiptV3Expectations {
+                    current_epoch: 0,
+                    ..expected.clone()
+                },
+                MlDsaV3Error::NotYetValid,
+            ),
+            (
+                ReceiptV3Expectations {
+                    current_epoch: 101,
+                    ..expected.clone()
+                },
+                MlDsaV3Error::Expired,
+            ),
+            (
+                ReceiptV3Expectations {
+                    registered_credential_id: [0xF3; 64],
+                    ..expected
+                },
+                MlDsaV3Error::UnregisteredCredential,
+            ),
+        ];
+        for (wrong_expectation, error) in cases {
+            assert_eq!(
+                verify_receipt_v3(&receipt, &envelope, &verifying_key, &wrong_expectation),
+                Err(error)
+            );
+        }
+    }
+
+    #[test]
+    #[allow(clippy::too_many_lines)]
+    fn node_owned_receipt_v3_golden_vector_matches_qwen_crypto_stack() {
+        // Mirrors `mil/palw/test-data/receipt_v3_golden_v1.json` in the node repo without changing
+        // this runtime's still-staged JSON schema. This pins the first shared boundary: ML-DSA key
+        // encoding/credential identity plus the node-owned LE canonical hash preimages.
+        fn node_hash(domain: &[u8], data: &[u8]) -> Hash64 {
+            let mut out = [0u8; 64];
+            out.copy_from_slice(
+                blake2b_simd::Params::new()
+                    .hash_length(64)
+                    .key(domain)
+                    .to_state()
+                    .update(data)
+                    .finalize()
+                    .as_bytes(),
+            );
+            out
+        }
+        fn hex(bytes: &[u8]) -> String {
+            use core::fmt::Write as _;
+            bytes
+                .iter()
+                .fold(String::with_capacity(bytes.len() * 2), |mut out, byte| {
+                    write!(&mut out, "{byte:02x}").unwrap();
+                    out
+                })
+        }
+        fn nullifier(credential: &Hash64, slot: u8) -> Hash64 {
+            let mut preimage = Vec::new();
+            preimage.extend_from_slice(&3u16.to_le_bytes());
+            preimage.extend_from_slice(&[0x11; 64]);
+            preimage.extend_from_slice(&[0x22; 64]);
+            preimage.extend_from_slice(&[0x33; 64]);
+            preimage.extend_from_slice(credential);
+            preimage.push(slot);
+            preimage.extend_from_slice(&10u64.to_le_bytes());
+            node_hash(b"misaka-palw-v3/execution-nullifier", &preimage)
+        }
+
+        let (_, credential_a) = verifying_key_and_credential_from_seed(&[1u8; 32]);
+        let (_, credential_b) = verifying_key_and_credential_from_seed(&[2u8; 32]);
+        assert_eq!(
+            hex(&credential_a),
+            "e11709cbe591e56b9d95e2ddcea57f5a38cc4a39fbe45acf161690c3eae238d494a80d93c88f601661e9846dafe3dfe208740c94dd875b563ee31fca41739041"
+        );
+
+        let tokens = [3555u32, 374, 279, 7290, 315, 279];
+        let mut output_preimage = Vec::new();
+        output_preimage.extend_from_slice(&3u16.to_le_bytes());
+        output_preimage.extend_from_slice(&[0x33; 64]);
+        output_preimage.extend_from_slice(&(tokens.len() as u64).to_le_bytes());
+        for token in tokens {
+            output_preimage.extend_from_slice(&token.to_le_bytes());
+        }
+        let output = node_hash(b"misaka-palw-v3/output", &output_preimage);
+        assert_eq!(
+            hex(&output),
+            "2def54f2dbd3511834e7ad1e739e90f15ea577dfb3c5ecd6dcb102c6d2dec90dd2fe39669f9fac42643e351f22b2ba9d65d884f0b3a6db913d9df91d6600006b"
+        );
+
+        let mut projection = Vec::new();
+        for field in [
+            [0x22; 64], [0x33; 64], output, [0x44; 64], [0x55; 64], [0x66; 64], [0x77; 64],
+        ] {
+            projection.extend_from_slice(&field);
+        }
+        projection.extend_from_slice(&41_692u64.to_le_bytes());
+        projection.extend_from_slice(&6u64.to_le_bytes());
+        projection.push(0);
+        let projection_digest = node_hash(b"misaka-palw-v3/projection", &projection);
+        assert_eq!(
+            hex(&projection_digest),
+            "a774bcad62404b2cbb024b87aebf0a24e351fa7e35dfd172957f70a5295f6128aa0cdffa183dae3d383ce329afdf07f382fd630b88008cf0b0a0b7625db67a85"
+        );
+
+        let nullifier_a = nullifier(&credential_a, 0);
+        assert_eq!(
+            hex(&nullifier_a),
+            "64a262eb153a4cecdf8f74c6d1fc8ba36bf28801311656888869dd519ab2331e387722c4f14beed8e45e1230608726cc9b21a5b9aec1db7f5e92ed9c585e3b52"
+        );
+        let mut body = Vec::new();
+        body.extend_from_slice(&3u16.to_le_bytes());
+        body.extend_from_slice(&[0x11; 64]);
+        body.extend_from_slice(&projection);
+        body.extend_from_slice(&[0xAA; 32]);
+        body.extend_from_slice(&[0xAB; 32]);
+        body.extend_from_slice(&credential_a);
+        body.push(0);
+        body.extend_from_slice(&nullifier_a);
+        body.extend_from_slice(&10u64.to_le_bytes());
+        body.extend_from_slice(&20u64.to_le_bytes());
+        assert_eq!(body.len(), 740);
+        let signing_digest = node_hash(b"misaka-palw-v3/receipt-signing", &body);
+        assert_eq!(
+            hex(&signing_digest),
+            "ca35a9bb32c50a305853c30a8922ce2b860252625f9cc125fc80e0c1b6385765b883b072ad715f1eb97ea3fc8ecf1f9c2ed7312eaf420fbce0204d068a4a1082"
+        );
+        assert_eq!(
+            hex(&node_hash(b"misaka-palw-v3/receipt-id", &signing_digest)),
+            "62f0723856c5378efcae164cf6d1baa56303c5bb036b61baf728a4078f5381db47c2fafbb3780c20fffb5fc74efe785445417cd7f1e1a48c69e3bfc581ff3493"
+        );
+
+        // The production Qwen types/functions—not a parallel fixture-only encoder—must emit the
+        // exact node bytes and digests above.
+        let projection_value = MatchProjectionV2 {
+            compute_set_id: [0x22; 64],
+            job_challenge: [0x33; 64],
+            output_commitment: output,
+            schedule_root: [0x44; 64],
+            execution_root: [0x55; 64],
+            route_root: [0x66; 64],
+            state_root: [0x77; 64],
+            canonical_compute_units: 41_692,
+            token_count: 6,
+            stop_reason: 0,
+        };
+        assert_eq!(projection_value.canonical_bytes(), projection);
+        assert_eq!(projection_value.digest(), projection_digest);
+        assert_eq!(
+            output_commitment_v3(&tokens, &[0x33; 64]),
+            output,
+            "production output commitment must consume canonical u32 token ids"
+        );
+        let receipt_a = ComputeReceiptV3 {
+            receipt_version: RECEIPT_V3_VERSION,
+            network_id: [0x11; 64],
+            projection: projection_value.clone(),
+            telemetry: ImplementationTelemetry {
+                runtime_class_id: [0xAA; 32],
+                runtime_manifest_hash: [0xAB; 32],
+            },
+            worker_credential_id: credential_a,
+            replica_slot: 0,
+            execution_nullifier: nullifier_a,
+            issued_epoch: 10,
+            expires_epoch: 20,
+        };
+        assert_eq!(receipt_a.canonical_bytes(), body);
+        assert_eq!(receipt_a.signing_digest(), signing_digest);
+        assert_eq!(
+            hex(&receipt_a.receipt_id()),
+            "62f0723856c5378efcae164cf6d1baa56303c5bb036b61baf728a4078f5381db47c2fafbb3780c20fffb5fc74efe785445417cd7f1e1a48c69e3bfc581ff3493"
+        );
+
+        let nullifier_b = nullifier(&credential_b, 1);
+        let (lo, hi) = if (credential_a, nullifier_a) <= (credential_b, nullifier_b) {
+            ((credential_a, nullifier_a), (credential_b, nullifier_b))
+        } else {
+            ((credential_b, nullifier_b), (credential_a, nullifier_a))
+        };
+        let mut pair_preimage = Vec::new();
+        pair_preimage.extend_from_slice(&projection_digest);
+        pair_preimage.extend_from_slice(&lo.0);
+        pair_preimage.extend_from_slice(&lo.1);
+        pair_preimage.extend_from_slice(&hi.0);
+        pair_preimage.extend_from_slice(&hi.1);
+        assert_eq!(
+            hex(&node_hash(b"misaka-palw-v3/pair-id", &pair_preimage)),
+            "faa2c2e8ba51eabfe88791b68b7ce6ac76470a4aaa7172a34e6824cad87618934b0d34024d1935c6df70551de8dd66da3306e5e9ef9fbd82785c0b2644e7f10f"
+        );
+        let receipt_b = ComputeReceiptV3 {
+            receipt_version: RECEIPT_V3_VERSION,
+            network_id: [0x11; 64],
+            projection: projection_value,
+            telemetry: ImplementationTelemetry {
+                runtime_class_id: [0xBB; 32],
+                runtime_manifest_hash: [0xBC; 32],
+            },
+            worker_credential_id: credential_b,
+            replica_slot: 1,
+            execution_nullifier: nullifier_b,
+            issued_epoch: 10,
+            expires_epoch: 20,
+        };
+        assert_eq!(
+            hex(&match_pair_v3(&receipt_a, &receipt_b).unwrap().pair_id),
+            "faa2c2e8ba51eabfe88791b68b7ce6ac76470a4aaa7172a34e6824cad87618934b0d34024d1935c6df70551de8dd66da3306e5e9ef9fbd82785c0b2644e7f10f"
+        );
+    }
+}
diff --git a/runtime-palw/src/testnet.rs b/runtime-palw/src/testnet.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c0e60b329d95a1ba1d835dfc18e2f3433dde25b6
--- /dev/null
+++ b/runtime-palw/src/testnet.rs
@@ -0,0 +1,590 @@
+//! T-shared (seeder-listed shared testnet) — the LLM/worker-side pieces.
+//!
+//! What a shared testnet needs from the runtime (node/seeder side is external):
+//! 1. [`JobSpecV2`] — a shared job spec distributed by the scheduler/seeder. Both replica workers
+//!    consume the same network, compute set, challenge, prompt count, and epoch window (with distinct
+//!    replica slots), so their receipts are matchable.
+//! 2. [`issue_receipt_v3`] — build + ML-DSA-sign a [`crate::receipt_v3::ComputeReceiptV3`] from the
+//!    spec and the worker's computed integer-canonical roots.
+//! 3. [`export_receipt`] / [`import_receipt`] — portable JSON for submission to a node.
+//! 4. [`receive_and_match`] — node-side-equivalent consumption: verify both ML-DSA envelopes and
+//!    run the v3 k=2 predicate. File-based [`store_receipt`]/[`load_receipts`] is the
+//!    testnet-grade store.
+
+pub use crate::receipt_v3::output_commitment_v3;
+use crate::receipt_v3::{
+    credential_id_from_verifying_key, execution_nullifier_v3, ComputeReceiptV3, Hash64,
+    ImplementationTelemetry, MatchProjectionV2, SignedEnvelopeV3, MLDSA87_ALGORITHM_ID,
+    MLDSA87_SIGNATURE_LEN, MLDSA87_VERIFYING_KEY_LEN, RECEIPT_V3_VERSION,
+};
+
+const MAX_SUBMISSION_JSON_BYTES: usize = 64 * 1024;
+const MAX_JOB_SPEC_JSON_BYTES: usize = 8 * 1024;
+
+/// Shared job spec (JSON) distributed to both replica workers. Every field is spec-supplied —
+/// the worker mints NO fresh randomness for consensus fields (that is what makes k=2 matchable).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct JobSpecV2 {
+    /// Network identity (testnet/mainnet separation).
+    pub network_id: Hash64,
+    /// Frozen job/model set identity.
+    pub compute_set_id: Hash64,
+    /// Epoch-beacon challenge the execution must bind.
+    pub job_challenge: Hash64,
+    /// This worker's replica slot (0 or 1).
+    pub replica_slot: u8,
+    /// Prompt/prefill token count committed by the assigned job.
+    pub prompt_token_count: u32,
+    /// Issue epoch.
+    pub issued_epoch: u64,
+    /// Expiry epoch.
+    pub expires_epoch: u64,
+}
+
+/// The worker's computed results for the job (integer-canonical roots).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WorkerResultV1 {
+    /// Output token ids (greedy).
+    pub tokens: Vec<u32>,
+    /// Canonical operation-schedule root.
+    pub schedule_root: Hash64,
+    /// Execution (trace/checkpoint) root.
+    pub execution_root: Hash64,
+    /// `MoE` expert-route root (zero for dense models).
+    pub route_root: Hash64,
+    /// Recurrent-state root (zero for dense models).
+    pub state_root: Hash64,
+    /// Semantic canonical compute units.
+    pub canonical_compute_units: u64,
+    /// Canonical stop reason.
+    pub stop_reason: u8,
+    /// Diagnostics (never matched).
+    pub telemetry: ImplementationTelemetry,
+}
+
+/// Build the v3 receipt body from a shared spec + worker result. All consensus fields come from
+/// the spec or deterministic derivation — no fresh worker randomness.
+#[must_use]
+pub fn build_receipt_v3(
+    spec: &JobSpecV2,
+    result: &WorkerResultV1,
+    worker_credential_id: Hash64,
+) -> ComputeReceiptV3 {
+    let projection = MatchProjectionV2 {
+        compute_set_id: spec.compute_set_id,
+        job_challenge: spec.job_challenge,
+        output_commitment: output_commitment_v3(&result.tokens, &spec.job_challenge),
+        schedule_root: result.schedule_root,
+        execution_root: result.execution_root,
+        route_root: result.route_root,
+        state_root: result.state_root,
+        canonical_compute_units: result.canonical_compute_units,
+        token_count: u64::from(spec.prompt_token_count) + result.tokens.len() as u64,
+        stop_reason: result.stop_reason,
+    };
+    let execution_nullifier = execution_nullifier_v3(
+        &spec.network_id,
+        &spec.compute_set_id,
+        &spec.job_challenge,
+        &worker_credential_id,
+        spec.replica_slot,
+        spec.issued_epoch,
+    );
+    ComputeReceiptV3 {
+        receipt_version: RECEIPT_V3_VERSION,
+        network_id: spec.network_id,
+        projection,
+        telemetry: result.telemetry.clone(),
+        worker_credential_id,
+        replica_slot: spec.replica_slot,
+        execution_nullifier,
+        issued_epoch: spec.issued_epoch,
+        expires_epoch: spec.expires_epoch,
+    }
+}
+
+// ---- portable JSON export/import (submission format) ----
+
+fn hex_of(b: &[u8]) -> String {
+    use std::fmt::Write as _;
+    b.iter()
+        .fold(String::with_capacity(b.len() * 2), |mut acc, x| {
+            let _ = write!(acc, "{x:02x}");
+            acc
+        })
+}
+fn unhex(s: &str) -> Option<Vec<u8>> {
+    if s.len() % 2 != 0 || !s.bytes().all(|c| c.is_ascii_hexdigit()) {
+        return None;
+    }
+    (0..s.len() / 2)
+        .map(|i| u8::from_str_radix(&s[2 * i..2 * i + 2], 16).ok())
+        .collect()
+}
+fn unhex64(s: &str) -> Option<Hash64> {
+    if s.len() != 2 * 64 {
+        return None;
+    }
+    let v = unhex(s)?;
+    let a: [u8; 64] = v.try_into().ok()?;
+    Some(a)
+}
+fn unhex32(s: &str) -> Option<[u8; 32]> {
+    if s.len() != 2 * 32 {
+        return None;
+    }
+    let v = unhex(s)?;
+    v.try_into().ok()
+}
+
+/// Serialize a job spec for distribution (originator -> verifier / seeder listing).
+#[must_use]
+pub fn export_job_spec(spec: &JobSpecV2) -> String {
+    serde_json::json!({
+        "schema": "misaka.palw.testnet-jobspec.v2",
+        "network_id": hex_of(&spec.network_id),
+        "compute_set_id": hex_of(&spec.compute_set_id),
+        "job_challenge": hex_of(&spec.job_challenge),
+        "replica_slot": spec.replica_slot,
+        "prompt_token_count": spec.prompt_token_count,
+        "issued_epoch": spec.issued_epoch,
+        "expires_epoch": spec.expires_epoch,
+    })
+    .to_string()
+}
+
+/// Parse a distributed job spec. Fail-closed on any missing/malformed field.
+#[must_use]
+pub fn import_job_spec(json: &str) -> Option<JobSpecV2> {
+    if json.len() > MAX_JOB_SPEC_JSON_BYTES {
+        return None;
+    }
+    let root: serde_json::Value = serde_json::from_str(json).ok()?;
+    if root.get("schema")?.as_str()? != "misaka.palw.testnet-jobspec.v2" {
+        return None;
+    }
+    let gs = |k: &str| -> Option<String> { Some(root.get(k)?.as_str()?.to_string()) };
+    Some(JobSpecV2 {
+        network_id: unhex64(&gs("network_id")?)?,
+        compute_set_id: unhex64(&gs("compute_set_id")?)?,
+        job_challenge: unhex64(&gs("job_challenge")?)?,
+        replica_slot: u8::try_from(root.get("replica_slot")?.as_u64()?).ok()?,
+        prompt_token_count: u32::try_from(root.get("prompt_token_count")?.as_u64()?).ok()?,
+        issued_epoch: root.get("issued_epoch")?.as_u64()?,
+        expires_epoch: root.get("expires_epoch")?.as_u64()?,
+    })
+}
+
+/// A portable v3 submission: receipt + envelope + verifying key.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SubmissionV3 {
+    /// The receipt body.
+    pub receipt: ComputeReceiptV3,
+    /// The ML-DSA-87 signed envelope.
+    pub envelope: SignedEnvelopeV3,
+    /// The signer's ML-DSA-87 verifying key.
+    pub verifying_key: Vec<u8>,
+}
+
+/// Serialize a submission to the portable JSON format (schema `misaka.palw.testnet-submission.v3`).
+#[must_use]
+pub fn export_receipt(sub: &SubmissionV3) -> String {
+    let r = &sub.receipt;
+    let p = &r.projection;
+    serde_json::json!({
+        "schema": "misaka.palw.testnet-submission.v3",
+        "receipt": {
+            "receipt_version": r.receipt_version,
+            "network_id": hex_of(&r.network_id),
+            "projection": {
+                "compute_set_id": hex_of(&p.compute_set_id),
+                "job_challenge": hex_of(&p.job_challenge),
+                "output_commitment": hex_of(&p.output_commitment),
+                "schedule_root": hex_of(&p.schedule_root),
+                "execution_root": hex_of(&p.execution_root),
+                "route_root": hex_of(&p.route_root),
+                "state_root": hex_of(&p.state_root),
+                "canonical_compute_units": p.canonical_compute_units,
+                "token_count": p.token_count,
+                "stop_reason": p.stop_reason,
+            },
+            "telemetry": {
+                "runtime_class_id": hex_of(&r.telemetry.runtime_class_id),
+                "runtime_manifest_hash": hex_of(&r.telemetry.runtime_manifest_hash),
+            },
+            "worker_credential_id": hex_of(&r.worker_credential_id),
+            "replica_slot": r.replica_slot,
+            "execution_nullifier": hex_of(&r.execution_nullifier),
+            "issued_epoch": r.issued_epoch,
+            "expires_epoch": r.expires_epoch,
+        },
+        "envelope": {
+            "body_digest": hex_of(&sub.envelope.body_digest),
+            "algorithm": sub.envelope.algorithm,
+            "signer_credential_id": hex_of(&sub.envelope.signer_credential_id),
+            "signature": hex_of(&sub.envelope.signature),
+        },
+        "verifying_key": hex_of(&sub.verifying_key),
+    })
+    .to_string()
+}
+
+/// Parse either supported Receipt v3 JSON layout:
+///
+/// - nested portable submission: `misaka.palw.testnet-submission.v3`;
+/// - flat canonical-integer envelope: `palw.integer-receipt/v3-envelope`.
+///
+/// Parsing is fail-closed. Besides widths and tags, this checks the key-derived credential,
+/// execution nullifier, body digest, and the flat layout's declared receipt id. Cryptographic and
+/// selected-chain admission verification remain separate operations.
+#[must_use]
+pub fn import_receipt(json: &str) -> Option<SubmissionV3> {
+    if json.len() > MAX_SUBMISSION_JSON_BYTES {
+        return None;
+    }
+    let root: serde_json::Value = serde_json::from_str(json).ok()?;
+    let schema = root.get("schema")?.as_str()?;
+    let (rj, flat_layout) = match schema {
+        "misaka.palw.testnet-submission.v3" => (root.get("receipt")?, false),
+        "palw.integer-receipt/v3-envelope" => {
+            if root.get("class")?.as_str()? != "canonical_integer_v0" {
+                return None;
+            }
+            (&root, true)
+        }
+        _ => return None,
+    };
+    let pj = rj.get("projection")?;
+    let tj = rj.get("telemetry")?;
+    let ej = root.get("envelope")?;
+    let gs = |o: &serde_json::Value, k: &str| -> Option<String> {
+        Some(o.get(k)?.as_str()?.to_string())
+    };
+    let receipt = ComputeReceiptV3 {
+        receipt_version: u16::try_from(rj.get("receipt_version")?.as_u64()?).ok()?,
+        network_id: unhex64(&gs(rj, "network_id")?)?,
+        projection: MatchProjectionV2 {
+            compute_set_id: unhex64(&gs(pj, "compute_set_id")?)?,
+            job_challenge: unhex64(&gs(pj, "job_challenge")?)?,
+            output_commitment: unhex64(&gs(pj, "output_commitment")?)?,
+            schedule_root: unhex64(&gs(pj, "schedule_root")?)?,
+            execution_root: unhex64(&gs(pj, "execution_root")?)?,
+            route_root: unhex64(&gs(pj, "route_root")?)?,
+            state_root: unhex64(&gs(pj, "state_root")?)?,
+            canonical_compute_units: pj.get("canonical_compute_units")?.as_u64()?,
+            token_count: pj.get("token_count")?.as_u64()?,
+            stop_reason: u8::try_from(pj.get("stop_reason")?.as_u64()?).ok()?,
+        },
+        telemetry: ImplementationTelemetry {
+            runtime_class_id: unhex32(&gs(tj, "runtime_class_id")?)?,
+            runtime_manifest_hash: unhex32(&gs(tj, "runtime_manifest_hash")?)?,
+        },
+        worker_credential_id: unhex64(&gs(rj, "worker_credential_id")?)?,
+        replica_slot: u8::try_from(rj.get("replica_slot")?.as_u64()?).ok()?,
+        execution_nullifier: unhex64(&gs(rj, "execution_nullifier")?)?,
+        issued_epoch: rj.get("issued_epoch")?.as_u64()?,
+        expires_epoch: rj.get("expires_epoch")?.as_u64()?,
+    };
+    let signature_hex = gs(ej, "signature")?;
+    let verifying_key_hex = gs(&root, "verifying_key")?;
+    if signature_hex.len() != 2 * MLDSA87_SIGNATURE_LEN
+        || verifying_key_hex.len() != 2 * MLDSA87_VERIFYING_KEY_LEN
+    {
+        return None;
+    }
+    let envelope = SignedEnvelopeV3 {
+        body_digest: unhex64(&gs(ej, "body_digest")?)?,
+        algorithm: u8::try_from(ej.get("algorithm")?.as_u64()?).ok()?,
+        signer_credential_id: unhex64(&gs(ej, "signer_credential_id")?)?,
+        signature: unhex(&signature_hex)?,
+    };
+    let verifying_key = unhex(&verifying_key_hex)?;
+    if receipt.receipt_version != RECEIPT_V3_VERSION
+        || receipt.replica_slot > 1
+        || receipt.issued_epoch > receipt.expires_epoch
+        || envelope.algorithm != MLDSA87_ALGORITHM_ID
+        || envelope.signature.len() != MLDSA87_SIGNATURE_LEN
+        || verifying_key.len() != MLDSA87_VERIFYING_KEY_LEN
+        || envelope.body_digest != receipt.signing_digest()
+    {
+        return None;
+    }
+    let credential = credential_id_from_verifying_key(&verifying_key);
+    if receipt.worker_credential_id != credential
+        || envelope.signer_credential_id != credential
+        || receipt.execution_nullifier
+            != execution_nullifier_v3(
+                &receipt.network_id,
+                &receipt.projection.compute_set_id,
+                &receipt.projection.job_challenge,
+                &receipt.worker_credential_id,
+                receipt.replica_slot,
+                receipt.issued_epoch,
+            )
+    {
+        return None;
+    }
+    if flat_layout {
+        let declared_receipt_id = unhex64(&gs(&root, "receipt_id")?)?;
+        if declared_receipt_id != receipt.receipt_id() {
+            return None;
+        }
+    }
+    Some(SubmissionV3 {
+        receipt,
+        envelope,
+        verifying_key,
+    })
+}
+
+/// Testnet-grade file store: one JSON file per receipt id.
+pub fn store_receipt(
+    dir: &std::path::Path,
+    sub: &SubmissionV3,
+) -> std::io::Result<std::path::PathBuf> {
+    std::fs::create_dir_all(dir)?;
+    let path = dir.join(format!("{}.v3.json", hex_of(&sub.receipt.receipt_id())));
+    std::fs::write(&path, export_receipt(sub))?;
+    Ok(path)
+}
+/// Load every stored submission in a directory (skips unparseable files — fail-closed per file).
+pub fn load_receipts(dir: &std::path::Path) -> std::io::Result<Vec<SubmissionV3>> {
+    let mut out = Vec::new();
+    for entry in std::fs::read_dir(dir)? {
+        let path = entry?.path();
+        if path.extension().and_then(|e| e.to_str()) == Some("json") {
+            if let Ok(text) = std::fs::read_to_string(&path) {
+                if let Some(sub) = import_receipt(&text) {
+                    out.push(sub);
+                }
+            }
+        }
+    }
+    Ok(out)
+}
+
+/// ML-DSA issuance + node-side consumption (feature `ml-dsa`).
+#[cfg(feature = "ml-dsa")]
+pub mod flow {
+    use super::{build_receipt_v3, JobSpecV2, SubmissionV3, WorkerResultV1};
+    use crate::receipt_v3::mldsa::{sign_receipt_v3, verify_receipt_v3, MlDsaV3Error};
+    use crate::receipt_v3::{
+        match_pair_v3, Hash64, MatchV3Error, MatchedPairV3, ReceiptV3Expectations,
+    };
+
+    /// Worker side: execute → build → sign → submission.
+    pub fn issue_receipt_v3(
+        spec: &JobSpecV2,
+        result: &WorkerResultV1,
+        worker_credential_id: Hash64,
+        signing_seed: &[u8; 32],
+    ) -> Result<SubmissionV3, MlDsaV3Error> {
+        let receipt = build_receipt_v3(spec, result, worker_credential_id);
+        let (envelope, verifying_key) =
+            sign_receipt_v3(&receipt, signing_seed, worker_credential_id)?;
+        Ok(SubmissionV3 {
+            receipt,
+            envelope,
+            verifying_key,
+        })
+    }
+
+    /// Errors for node-side consumption.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub enum ReceiveError {
+        /// Replica A failed selected-chain admission verification.
+        VerifyA(MlDsaV3Error),
+        /// Replica B failed selected-chain admission verification.
+        VerifyB(MlDsaV3Error),
+        /// The pair failed the k=2 predicate.
+        Match(MatchV3Error),
+    }
+
+    /// Node-side-equivalent admission: independently verify both submissions against selected-chain
+    /// job, epoch, network, slot, and registry expectations before evaluating the v3 k=2 predicate.
+    /// Worker-supplied keys or body fields are never used as registry expectations.
+    pub fn receive_and_match(
+        a: &SubmissionV3,
+        b: &SubmissionV3,
+        expected_a: &ReceiptV3Expectations,
+        expected_b: &ReceiptV3Expectations,
+    ) -> Result<MatchedPairV3, ReceiveError> {
+        verify_receipt_v3(&a.receipt, &a.envelope, &a.verifying_key, expected_a)
+            .map_err(ReceiveError::VerifyA)?;
+        verify_receipt_v3(&b.receipt, &b.envelope, &b.verifying_key, expected_b)
+            .map_err(ReceiveError::VerifyB)?;
+        match_pair_v3(&a.receipt, &b.receipt).map_err(ReceiveError::Match)
+    }
+}
+
+#[cfg(all(test, feature = "ml-dsa"))]
+mod tests {
+    use super::flow::{issue_receipt_v3, receive_and_match, ReceiveError};
+    use super::*;
+    use crate::receipt_v3::mldsa::{verifying_key_and_credential_from_seed, MlDsaV3Error};
+    use crate::receipt_v3::{MatchV3Error, ReceiptV3Expectations};
+
+    fn credential(seed_byte: u8) -> Hash64 {
+        verifying_key_and_credential_from_seed(&[seed_byte; 32]).1
+    }
+
+    fn spec(slot: u8) -> JobSpecV2 {
+        JobSpecV2 {
+            network_id: [0x11; 64],
+            compute_set_id: [0x22; 64],
+            job_challenge: [0x33; 64],
+            replica_slot: slot,
+            prompt_token_count: 4,
+            issued_epoch: 1,
+            expires_epoch: 100,
+        }
+    }
+
+    fn expectations(submission: &SubmissionV3) -> ReceiptV3Expectations {
+        let receipt = &submission.receipt;
+        ReceiptV3Expectations {
+            network_id: receipt.network_id,
+            compute_set_id: receipt.projection.compute_set_id,
+            job_challenge: receipt.projection.job_challenge,
+            replica_slot: receipt.replica_slot,
+            issued_epoch: receipt.issued_epoch,
+            expires_epoch: receipt.expires_epoch,
+            current_epoch: 50,
+            registered_credential_id: receipt.worker_credential_id,
+        }
+    }
+
+    fn export_flat_integer_receipt(submission: &SubmissionV3) -> String {
+        let mut nested: serde_json::Value =
+            serde_json::from_str(&export_receipt(submission)).expect("nested JSON");
+        let mut receipt = nested.get_mut("receipt").expect("receipt").take();
+        let envelope = nested.get_mut("envelope").expect("envelope").take();
+        let verifying_key = nested
+            .get_mut("verifying_key")
+            .expect("verifying key")
+            .take();
+        let object = receipt.as_object_mut().expect("receipt object");
+        object.insert(
+            "schema".to_owned(),
+            serde_json::Value::String("palw.integer-receipt/v3-envelope".to_owned()),
+        );
+        object.insert(
+            "class".to_owned(),
+            serde_json::Value::String("canonical_integer_v0".to_owned()),
+        );
+        object.insert(
+            "receipt_id".to_owned(),
+            serde_json::Value::String(hex_of(&submission.receipt.receipt_id())),
+        );
+        object.insert("envelope".to_owned(), envelope);
+        object.insert("verifying_key".to_owned(), verifying_key);
+        receipt.to_string()
+    }
+    fn result(class: u8) -> WorkerResultV1 {
+        WorkerResultV1 {
+            tokens: vec![3555, 374, 279, 7290, 315, 279],
+            schedule_root: [0x44; 64],
+            execution_root: [0x55; 64],
+            route_root: [0u8; 64],
+            state_root: [0u8; 64],
+            canonical_compute_units: 41692,
+            stop_reason: 0,
+            telemetry: ImplementationTelemetry {
+                runtime_class_id: [class; 32],
+                runtime_manifest_hash: [class; 32],
+            },
+        }
+    }
+
+    #[test]
+    fn t_shared_full_round_trip_cross_vendor() {
+        // Two independent workers on different hardware classes execute the SAME shared job spec,
+        // export their submissions, and the (node-equivalent) receiver verifies + matches them.
+        let sub_a = issue_receipt_v3(&spec(0), &result(0xAA), credential(1), &[1; 32]).unwrap();
+        let sub_b = issue_receipt_v3(&spec(1), &result(0xBB), credential(2), &[2; 32]).unwrap();
+        let job_json = export_job_spec(&spec(0));
+        assert_eq!(import_job_spec(&job_json), Some(spec(0)));
+        assert!(import_job_spec(&job_json.replace("jobspec.v2", "jobspec.v1")).is_none());
+        // portable JSON round trip
+        let ja = export_receipt(&sub_a);
+        let jb = export_receipt(&sub_b);
+        let ra = import_receipt(&ja).unwrap();
+        let rb = import_receipt(&jb).unwrap();
+        assert_eq!(ra, sub_a);
+        assert_eq!(rb, sub_b);
+        // Both CLI layouts reconstruct the identical canonical body/envelope/key tuple.
+        assert_eq!(
+            import_receipt(&export_flat_integer_receipt(&sub_a)),
+            Some(sub_a.clone())
+        );
+        assert_eq!(ra.receipt.projection.token_count, 10);
+        // file store round trip
+        let dir = std::env::temp_dir().join(format!("palw-tshared-test-{}", std::process::id()));
+        store_receipt(&dir, &sub_a).unwrap();
+        store_receipt(&dir, &sub_b).unwrap();
+        let loaded = load_receipts(&dir).unwrap();
+        assert_eq!(loaded.len(), 2);
+        std::fs::remove_dir_all(&dir).unwrap();
+        // node-side verify + k=2 match (cross-vendor: telemetry differs)
+        let expected_a = expectations(&ra);
+        let expected_b = expectations(&rb);
+        let pair = receive_and_match(&ra, &rb, &expected_a, &expected_b).unwrap();
+        let pair_rev = receive_and_match(&rb, &ra, &expected_b, &expected_a).unwrap();
+        assert_eq!(pair.pair_id, pair_rev.pair_id);
+    }
+
+    #[test]
+    fn t_shared_rejects_divergence_and_forgeries() {
+        let sub_a = issue_receipt_v3(&spec(0), &result(0xAA), credential(1), &[1; 32]).unwrap();
+        // diverged output (different tokens) → projection mismatch
+        let mut bad = result(0xBB);
+        bad.tokens = vec![1, 2, 3];
+        let sub_c = issue_receipt_v3(&spec(1), &bad, credential(3), &[3; 32]).unwrap();
+        assert!(matches!(
+            receive_and_match(&sub_a, &sub_c, &expectations(&sub_a), &expectations(&sub_c)),
+            Err(ReceiveError::Match(MatchV3Error::ProjectionMismatch(_)))
+        ));
+        // same credential (sybil self-pair) rejected
+        let sub_d = issue_receipt_v3(&spec(1), &result(0xBB), credential(1), &[1; 32]).unwrap();
+        assert!(matches!(
+            receive_and_match(&sub_a, &sub_d, &expectations(&sub_a), &expectations(&sub_d)),
+            Err(ReceiveError::Match(MatchV3Error::NotIndependent(
+                "worker_credential_id"
+            )))
+        ));
+        // tampered submission JSON (signature of another body) fails verify
+        let sub_b = issue_receipt_v3(&spec(1), &result(0xBB), credential(2), &[2; 32]).unwrap();
+        let mut forged = sub_b.clone();
+        forged.receipt.projection.canonical_compute_units += 1;
+        assert!(matches!(
+            receive_and_match(
+                &sub_a,
+                &forged,
+                &expectations(&sub_a),
+                &expectations(&sub_b)
+            ),
+            Err(ReceiveError::VerifyB(_))
+        ));
+        // A valid signature under a fresh self-generated key is not admission without registry state.
+        let mut unregistered = expectations(&sub_a);
+        unregistered.registered_credential_id = [0xFE; 64];
+        assert_eq!(
+            receive_and_match(&sub_a, &sub_b, &unregistered, &expectations(&sub_b)),
+            Err(ReceiveError::VerifyA(MlDsaV3Error::UnregisteredCredential))
+        );
+        // wrong algorithm tag is unrepresentable through import
+        let mut j = export_receipt(&sub_b);
+        j = j.replace("\"algorithm\":1", "\"algorithm\":0");
+        assert!(import_receipt(&j).is_none());
+        let mut flat: serde_json::Value =
+            serde_json::from_str(&export_flat_integer_receipt(&sub_b)).unwrap();
+        flat["receipt_id"] = serde_json::Value::String(hex_of(&[0xFF; 64]));
+        assert!(import_receipt(&flat.to_string()).is_none());
+        let mut oversized: serde_json::Value =
+            serde_json::from_str(&export_receipt(&sub_b)).unwrap();
+        oversized["padding"] = serde_json::Value::String("x".repeat(MAX_SUBMISSION_JSON_BYTES));
+        let oversized = oversized.to_string();
+        assert!(oversized.len() > MAX_SUBMISSION_JSON_BYTES);
+        assert!(import_receipt(&oversized).is_none());
+    }
+}
diff --git a/runtime-palw/test-data/receipt_da_object_v2_golden_v1.json b/runtime-palw/test-data/receipt_da_object_v2_golden_v1.json
new file mode 100644
index 0000000000000000000000000000000000000000..7a868bf9d7f30c2c42135d31da1384cec686f8e5
--- /dev/null
+++ b/runtime-palw/test-data/receipt_da_object_v2_golden_v1.json
@@ -0,0 +1,32 @@
+{
+  "schema": "misaka.palw.receipt-da-object-v2-golden.v1",
+  "test_only": true,
+  "node_context_schema": "misaka.palw.node-da-object-v2-context.v1",
+  "network_id": "10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010",
+  "palw_network_id": 110,
+  "batch_id": "02020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202",
+  "leaf_index": 7,
+  "provider_a_bond": {
+    "transaction_id": "c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1",
+    "index": 0
+  },
+  "provider_b_bond": {
+    "transaction_id": "c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2",
+    "index": 1
+  },
+  "receipt_v3_compute_set_id": "31313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131",
+  "receipt_v3_job_challenge": "32323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232",
+  "receipt_v3_issued_epoch": 5,
+  "receipt_v3_expires_epoch": 20,
+  "receipt_seed_byte_a": 17,
+  "receipt_seed_byte_b": 34,
+  "owner_seed_byte_a": 161,
+  "owner_seed_byte_b": 178,
+  "authorization_nonce_a": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1",
+  "authorization_nonce_b": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2",
+  "private_match_commitment": "560537e0660dd26c396fa36dcf73316f9d3acff87d591cd096fd02387575136c4baaf6fcbb8a3e85809a046a92b46c767eab6b30ce2440f1b0fde779f4ca3545",
+  "object_version": 2,
+  "object_len": 31288,
+  "chunk_count": 2,
+  "root": "3eb971b4ab8f3aced3e6cc77c6794b6ca90f85c2f7f244892e2610660f437c89c051d9abed59d8040ade9b755867b41e0a2410ddd8092df692b80e9a6c7b316b"
+}
diff --git a/runtime-palw/tests/lifecycle_cli.rs b/runtime-palw/tests/lifecycle_cli.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d791b6b1246af0e06382dd19db822a3fd73b9e56
--- /dev/null
+++ b/runtime-palw/tests/lifecycle_cli.rs
@@ -0,0 +1,187 @@
+//! End-to-end CLI coverage for signed lifecycle event ingestion and replay handling.
+
+#![cfg(feature = "ml-dsa")]
+#![allow(clippy::too_many_lines)]
+
+use ed25519_dalek::{Signer, SigningKey};
+use runtime_palw::commitment::CanonicalSerialize;
+use runtime_palw::lifecycle::{
+    lifecycle_event_to_hex, LifecycleEventBodyV1, LifecycleEventPayloadV1, SignedLifecycleEventV1,
+    LIFECYCLE_EVENT_VERSION_V1, LIFECYCLE_STATE_VERSION_V1,
+};
+use runtime_palw::receipt::signer_key_id;
+use std::process::Command;
+
+fn h(byte: u8) -> [u8; 64] {
+    [byte; 64]
+}
+
+fn hex(bytes: &[u8]) -> String {
+    use std::fmt::Write as _;
+    bytes
+        .iter()
+        .fold(String::with_capacity(bytes.len() * 2), |mut out, byte| {
+            let _ = write!(out, "{byte:02x}");
+            out
+        })
+}
+
+fn run(args: &[&str]) -> std::process::Output {
+    Command::new(env!("CARGO_BIN_EXE_palw-lifecycle"))
+        .args(args)
+        .output()
+        .unwrap()
+}
+
+#[test]
+fn cli_bootstrap_apply_replay_status_and_tamper() {
+    let mut random = [0_u8; 8];
+    getrandom::getrandom(&mut random).unwrap();
+    let dir = std::env::temp_dir().join(format!(
+        "palw-lifecycle-cli-{}-{}",
+        std::process::id(),
+        u64::from_le_bytes(random)
+    ));
+    std::fs::create_dir(&dir).unwrap();
+    let db = dir.join("lifecycle.sqlite");
+    let event_path = dir.join("fund.event.json");
+    let tampered_path = dir.join("tampered.event.hex");
+    let db_text = db.to_str().unwrap();
+
+    let init = run(&["init", "--db", db_text]);
+    assert!(
+        init.status.success(),
+        "{}",
+        String::from_utf8_lossy(&init.stderr)
+    );
+    let forbidden = run(&[
+        "init",
+        "--db",
+        db_text,
+        "--private-key",
+        "must-not-be-accepted",
+    ]);
+    assert!(!forbidden.status.success());
+    assert!(String::from_utf8_lossy(&forbidden.stderr).contains("forbidden option"));
+    let typo = run(&["status", "--db", db_text, "--netwrok", "00"]);
+    assert!(!typo.status.success());
+    assert!(String::from_utf8_lossy(&typo.stderr).contains("unknown"));
+    let help = run(&["--help"]);
+    assert!(help.status.success());
+    assert!(!String::from_utf8_lossy(&help.stderr).contains("\n+"));
+
+    let key = SigningKey::from_bytes(&[0x51; 32]);
+    let network = h(0x11);
+    let authority = run(&[
+        "authority-add",
+        "--db",
+        db_text,
+        "--network",
+        &hex(&network),
+        "--verifying-key",
+        &hex(key.verifying_key().as_bytes()),
+        "--permissions",
+        "funding,lifecycle,admission,terminal,bond,slash",
+        "--valid-from",
+        "0",
+        "--valid-through",
+        "100",
+    ]);
+    assert!(
+        authority.status.success(),
+        "{}",
+        String::from_utf8_lossy(&authority.stderr)
+    );
+
+    let body = LifecycleEventBodyV1 {
+        version: LIFECYCLE_EVENT_VERSION_V1,
+        state_version: LIFECYCLE_STATE_VERSION_V1,
+        network_id: network,
+        epoch: 1,
+        sequence: 1,
+        nonce: h(0x22),
+        payload: LifecycleEventPayloadV1::FundingConfirmed {
+            escrow_id: h(0x33),
+            requester_id: h(0x44),
+            asset_id: h(0x55),
+            amount: 100,
+            expires_epoch: 20,
+            funding_reference: h(0x66),
+        },
+    };
+    let signature = key.sign(&body.signing_digest()).to_bytes();
+    let event =
+        SignedLifecycleEventV1::from_parts(body, signer_key_id(&key.verifying_key()), signature);
+    std::fs::write(
+        &event_path,
+        serde_json::json!({
+            "schema": "misaka.palw.lifecycle-event.v1",
+            "canonical_event_hex": lifecycle_event_to_hex(&event),
+        })
+        .to_string(),
+    )
+    .unwrap();
+
+    let applied = run(&[
+        "fund",
+        "--db",
+        db_text,
+        "--event",
+        event_path.to_str().unwrap(),
+    ]);
+    assert!(
+        applied.status.success(),
+        "{}",
+        String::from_utf8_lossy(&applied.stderr)
+    );
+    let applied_json: serde_json::Value = serde_json::from_slice(&applied.stdout).unwrap();
+    assert_eq!(applied_json["newly_applied"], true);
+    assert_eq!(applied_json["consensus_enforced"], false);
+
+    let replay = run(&[
+        "fund",
+        "--db",
+        db_text,
+        "--event",
+        event_path.to_str().unwrap(),
+    ]);
+    assert!(replay.status.success());
+    let replay_json: serde_json::Value = serde_json::from_slice(&replay.stdout).unwrap();
+    assert_eq!(replay_json["newly_applied"], false);
+
+    let status = run(&[
+        "status",
+        "--db",
+        db_text,
+        "--network",
+        &hex(&network),
+        "--escrow",
+        &hex(&h(0x33)),
+    ]);
+    assert!(status.status.success());
+    let status_json: serde_json::Value = serde_json::from_slice(&status.stdout).unwrap();
+    assert_eq!(status_json["state"], "Funded");
+    assert_eq!(status_json["sequence"], 1);
+
+    let wrong_typed_command = run(&[
+        "lock",
+        "--db",
+        db_text,
+        "--event",
+        event_path.to_str().unwrap(),
+    ]);
+    assert!(!wrong_typed_command.status.success());
+
+    let mut tampered = event.canonical_bytes();
+    *tampered.last_mut().unwrap() ^= 1;
+    std::fs::write(&tampered_path, hex(&tampered)).unwrap();
+    let rejected = run(&[
+        "fund",
+        "--db",
+        db_text,
+        "--event",
+        tampered_path.to_str().unwrap(),
+    ]);
+    assert!(!rejected.status.success());
+    assert!(String::from_utf8_lossy(&rejected.stderr).contains("signature"));
+}
diff --git a/scripts/qi35_calibrate.py b/scripts/qi35_calibrate.py
new file mode 100644
index 0000000000000000000000000000000000000000..26b307a40175ab0eeae850b1877386f449db03e2
--- /dev/null
+++ b/scripts/qi35_calibrate.py
@@ -0,0 +1,560 @@
+#!/usr/bin/env python3
+"""Measure canonical-integer greedy agreement against pinned llama.cpp fp inference."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import queue
+import signal
+import socket
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+from collections import deque
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any, Iterable
+
+try:
+    from scripts.qi35_soak import (
+        Backend,
+        Prompt,
+        ServeProcess,
+        SoakError,
+        artifact_record,
+        command_for,
+        host_record,
+        utc_now,
+        write_new_json,
+    )
+except ModuleNotFoundError:  # Direct execution from the scripts directory.
+    from qi35_soak import (  # type: ignore[no-redef]
+        Backend,
+        Prompt,
+        ServeProcess,
+        SoakError,
+        artifact_record,
+        command_for,
+        host_record,
+        utc_now,
+        write_new_json,
+    )
+
+
+SCHEMA = "misaka.qi35.fp-calibration.v2"
+LEGACY_UNATTESTED_SCHEMA = "misaka.qi35.fp-calibration.v1"
+CORPUS_SCHEMA = "misaka.qi35.calibration-corpus.v1"
+PROXY_ENVIRONMENT_KEYS = {
+    "ALL_PROXY",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "NO_PROXY",
+    "all_proxy",
+    "http_proxy",
+    "https_proxy",
+    "no_proxy",
+}
+
+
+class RejectRedirectHandler(urllib.request.HTTPRedirectHandler):
+    """Fail closed instead of following a loopback response to another origin."""
+
+    def redirect_request(self, request, file_pointer, code, message, headers, new_url):
+        file_pointer.close()
+        raise urllib.error.HTTPError(
+            request.full_url,
+            code,
+            "redirects are disabled for direct loopback inference",
+            headers,
+            None,
+        )
+
+
+def direct_http_opener() -> urllib.request.OpenerDirector:
+    """Return an HTTP opener that never consults inherited proxy settings."""
+    return urllib.request.build_opener(
+        urllib.request.ProxyHandler({}),
+        RejectRedirectHandler(),
+    )
+
+
+def close_http_error(error: BaseException) -> None:
+    if isinstance(error, urllib.error.HTTPError):
+        error.close()
+
+
+def clean_llama_environment() -> dict[str, str]:
+    prefixes = ("QI35_", "LLAMA_ARG_", "GGML_", "PALW_")
+    environment = {
+        key: value
+        for key, value in os.environ.items()
+        if not key.startswith(prefixes) and key not in PROXY_ENVIRONMENT_KEYS
+    }
+    environment.update({"LC_ALL": "C", "LANG": "C"})
+    return environment
+
+
+def free_local_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as listener:
+        listener.bind(("127.0.0.1", 0))
+        return int(listener.getsockname()[1])
+
+
+class LlamaServer:
+    def __init__(self, args: argparse.Namespace) -> None:
+        self.port = free_local_port()
+        self.url = f"http://127.0.0.1:{self.port}"
+        self.opener = direct_http_opener()
+        self.log_tail: deque[str] = deque(maxlen=160)
+        command = [
+            str(args.llama_server),
+            "-m",
+            str(args.model),
+            "-c",
+            str(args.context_size),
+            "-np",
+            "1",
+            "-ngl",
+            args.llama_gpu_layers,
+            "--host",
+            "127.0.0.1",
+            "--port",
+            str(self.port),
+            "--no-webui",
+            "--no-warmup",
+        ]
+        self.process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            bufsize=1,
+            env=clean_llama_environment(),
+            start_new_session=(os.name == "posix"),
+        )
+        assert self.process.stdout is not None
+        assert self.process.stderr is not None
+        threading.Thread(target=self._drain, args=(self.process.stdout,), daemon=True).start()
+        threading.Thread(target=self._drain, args=(self.process.stderr,), daemon=True).start()
+        try:
+            self._wait_ready(args.startup_timeout)
+        except BaseException:
+            self.terminate()
+            raise
+
+    def _drain(self, stream: Iterable[str]) -> None:
+        for line in stream:
+            self.log_tail.append(line.rstrip("\n"))
+
+    def _wait_ready(self, timeout: float) -> None:
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if self.process.poll() is not None:
+                raise SoakError(
+                    f"llama-server exited {self.process.returncode}: {list(self.log_tail)[-12:]}"
+                )
+            try:
+                with self.opener.open(f"{self.url}/health", timeout=1) as response:
+                    if response.status == 200:
+                        return
+            except (OSError, urllib.error.URLError) as error:
+                close_http_error(error)
+                pass
+            time.sleep(0.2)
+        raise SoakError("llama-server startup timed out")
+
+    def complete(self, prompt: Prompt, args: argparse.Namespace) -> dict[str, Any]:
+        body = {
+            "prompt": list(prompt.ids),
+            "n_predict": args.max_new,
+            "return_tokens": True,
+            "temperature": 0.0,
+            "top_k": 0,
+            "top_p": 1.0,
+            "min_p": 0.0,
+            "repeat_penalty": 1.0,
+            "presence_penalty": 0.0,
+            "frequency_penalty": 0.0,
+            "dry_multiplier": 0.0,
+            "cache_prompt": False,
+            "ignore_eos": True,
+            "seed": 0,
+        }
+        request = urllib.request.Request(
+            f"{self.url}/completion",
+            data=json.dumps(body).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        try:
+            with self.opener.open(request, timeout=args.request_timeout) as response:
+                result = json.load(response)
+        except (OSError, urllib.error.URLError, json.JSONDecodeError) as error:
+            close_http_error(error)
+            raise SoakError(f"llama-server request failed for {prompt.name!r}") from error
+        if not isinstance(result, dict):
+            raise SoakError(f"llama-server returned a non-object for {prompt.name!r}")
+        tokens = result.get("tokens")
+        if not isinstance(tokens, list) or not all(isinstance(value, int) for value in tokens):
+            raise SoakError(f"llama-server omitted raw tokens for {prompt.name!r}")
+        if len(tokens) != args.max_new:
+            raise SoakError(
+                f"llama-server returned {len(tokens)} tokens for {prompt.name!r}, "
+                f"expected {args.max_new}"
+            )
+        timings = result.get("timings", {})
+        return {
+            "generated": tokens,
+            "stop_type": result.get("stop_type"),
+            "predicted_ms": timings.get("predicted_ms"),
+            "predicted_per_second": timings.get("predicted_per_second"),
+            "prompt_ms": timings.get("prompt_ms"),
+            "tokens_cached": result.get("tokens_cached"),
+        }
+
+    def terminate(self) -> None:
+        if self.process.poll() is not None:
+            return
+        try:
+            if os.name == "posix":
+                os.killpg(self.process.pid, signal.SIGTERM)
+            else:
+                self.process.terminate()
+            self.process.wait(timeout=15)
+        except (ProcessLookupError, subprocess.TimeoutExpired):
+            if self.process.poll() is None:
+                self.process.kill()
+                self.process.wait(timeout=5)
+
+
+def load_corpus(path: Path, tokenizer: Path, vocab_size: int) -> tuple[list[Prompt], list[dict[str, Any]]]:
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    if raw.get("schema") != CORPUS_SCHEMA:
+        raise SoakError(f"calibration corpus must use schema {CORPUS_SCHEMA!r}")
+    tokenizer_hash = artifact_record(tokenizer)["sha256"]
+    if raw.get("tokenizer_sha256") != tokenizer_hash:
+        raise SoakError("calibration corpus tokenizer hash does not match --tokenizer")
+    entries = raw.get("prompts")
+    if not isinstance(entries, list) or not entries:
+        raise SoakError("calibration corpus must contain prompts")
+    prompts: list[Prompt] = []
+    names: set[str] = set()
+    for entry in entries:
+        if not isinstance(entry, dict):
+            raise SoakError("calibration prompt must be an object")
+        name = entry.get("name")
+        text = entry.get("text")
+        ids = entry.get("ids")
+        if not isinstance(name, str) or not name or name in names:
+            raise SoakError(f"invalid or duplicate calibration prompt name {name!r}")
+        if not isinstance(text, str) or not isinstance(ids, list) or not ids:
+            raise SoakError(f"calibration prompt {name!r} is incomplete")
+        if not all(isinstance(value, int) and 0 <= value < vocab_size for value in ids):
+            raise SoakError(f"calibration prompt {name!r} has an invalid token id")
+        names.add(name)
+        prompts.append(Prompt(name=name, ids=tuple(ids)))
+    return prompts, entries
+
+
+def common_prefix_length(left: list[int], right: list[int]) -> int:
+    count = 0
+    for left_value, right_value in zip(left, right):
+        if left_value != right_value:
+            break
+        count += 1
+    return count
+
+
+def runtime_drift(rows: list[dict[str, Any]], prompt_names: list[str], runtime: str) -> list[dict[str, Any]]:
+    failures: list[dict[str, Any]] = []
+    for prompt_name in prompt_names:
+        selected = [row for row in rows if row["prompt"] == prompt_name]
+        expected = selected[0]["generated"]
+        for row in selected[1:]:
+            if row["generated"] != expected:
+                failures.append(
+                    {
+                        "kind": "runtime_drift",
+                        "runtime": runtime,
+                        "prompt": prompt_name,
+                        "iteration": row["iteration"],
+                        "expected": expected,
+                        "actual": row["generated"],
+                    }
+                )
+    return failures
+
+
+def quality_summary(
+    integer_rows: list[dict[str, Any]],
+    fp_rows: list[dict[str, Any]],
+    prompt_names: list[str],
+) -> dict[str, Any]:
+    per_prompt: list[dict[str, Any]] = []
+    prefix_total = 0
+    exact_position_total = 0
+    token_total = 0
+    for prompt_name in prompt_names:
+        integer = next(row["generated"] for row in integer_rows if row["prompt"] == prompt_name)
+        fp = next(row["generated"] for row in fp_rows if row["prompt"] == prompt_name)
+        prefix = common_prefix_length(integer, fp)
+        exact_positions = sum(left == right for left, right in zip(integer, fp))
+        compared = min(len(integer), len(fp))
+        prefix_total += prefix
+        exact_position_total += exact_positions
+        token_total += compared
+        per_prompt.append(
+            {
+                "prompt": prompt_name,
+                "integer": integer,
+                "fp": fp,
+                "prefix_match_tokens": prefix,
+                "compared_tokens": compared,
+                "fully_identical": integer == fp,
+                "first_divergence_index": None if prefix == compared else prefix,
+                "exact_position_matches": exact_positions,
+            }
+        )
+    return {
+        "prompt_count": len(prompt_names),
+        "fully_identical_prompts": sum(item["fully_identical"] for item in per_prompt),
+        "prefix_match_tokens": prefix_total,
+        "compared_tokens": token_total,
+        "prefix_match_fraction": prefix_total / token_total if token_total else None,
+        "exact_position_matches": exact_position_total,
+        "exact_position_fraction": exact_position_total / token_total if token_total else None,
+        "per_prompt": per_prompt,
+        "interpretation": (
+            "Only tokens before the first divergence share an identical autoregressive context; "
+            "later position matches are diagnostic, not an accuracy claim."
+        ),
+    }
+
+
+def validate_runtime_libraries(paths: list[Path], option: str) -> None:
+    """Require a non-empty, unique manifest of existing runtime libraries."""
+    if not paths:
+        raise SoakError(f"{option} requires at least one runtime library")
+    for path in paths:
+        if not path.is_file():
+            raise SoakError(f"{option} is not a file: {path}")
+    resolved = [path.resolve() for path in paths]
+    if len(set(resolved)) != len(resolved):
+        raise SoakError(f"{option} entries must be unique")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--engine", required=True, type=Path)
+    parser.add_argument("--source", required=True, type=Path)
+    parser.add_argument("--tables", required=True, type=Path)
+    parser.add_argument("--model", required=True, type=Path)
+    parser.add_argument("--tokenizer", required=True, type=Path)
+    parser.add_argument("--corpus", required=True, type=Path)
+    parser.add_argument(
+        "--engine-library",
+        action="append",
+        required=True,
+        type=Path,
+        help="Canonical engine runtime library; repeat for every non-system DSO",
+    )
+    parser.add_argument("--llama-server", required=True, type=Path)
+    parser.add_argument(
+        "--llama-library",
+        action="append",
+        required=True,
+        type=Path,
+        help="Loaded llama/ggml shared library; repeat for every non-system runtime library",
+    )
+    parser.add_argument("--llama-revision", required=True)
+    parser.add_argument("--llama-patch", required=True, type=Path)
+    parser.add_argument("--library-dir", required=True, type=Path)
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument("--iterations", type=int, default=3)
+    parser.add_argument("--max-new", type=int, default=8)
+    parser.add_argument("--threads", type=int, default=8)
+    parser.add_argument("--vocab-size", type=int, default=248_320)
+    parser.add_argument("--context-size", type=int, default=1024)
+    parser.add_argument("--llama-gpu-layers", default="all")
+    parser.add_argument("--startup-timeout", type=float, default=300.0)
+    parser.add_argument("--request-timeout", type=float, default=300.0)
+    args = parser.parse_args()
+    for name in (
+        "engine",
+        "source",
+        "tables",
+        "model",
+        "tokenizer",
+        "corpus",
+        "llama_server",
+        "llama_patch",
+    ):
+        if not getattr(args, name).is_file():
+            parser.error(f"--{name.replace('_', '-')} is not a file")
+    if not args.library_dir.is_dir():
+        parser.error("--library-dir is not a directory")
+    for paths, option in (
+        (args.engine_library, "--engine-library"),
+        (args.llama_library, "--llama-library"),
+    ):
+        try:
+            validate_runtime_libraries(paths, option)
+        except SoakError as error:
+            parser.error(str(error))
+    for name in ("iterations", "max_new", "threads", "vocab_size", "context_size"):
+        if getattr(args, name) <= 0:
+            parser.error(f"--{name.replace('_', '-')} must be positive")
+    return args
+
+
+def run(args: argparse.Namespace) -> dict[str, Any]:
+    prompts, corpus_entries = load_corpus(args.corpus, args.tokenizer, args.vocab_size)
+    prompt_names = [prompt.name for prompt in prompts]
+    started_at = utc_now()
+    integer_rows: list[dict[str, Any]] = []
+    fp_rows: list[dict[str, Any]] = []
+
+    integer_backend = Backend(
+        name="canonical-integer-metal-v3",
+        executable=args.engine,
+        flags=("--metal-v3",),
+        environment={"DYLD_LIBRARY_PATH": str(args.library_dir.resolve())},
+    )
+    engine_args = SimpleNamespace(
+        model=args.model,
+        tables=args.tables,
+        threads=args.threads,
+        max_new=args.max_new,
+    )
+    integer_process: ServeProcess | None = None
+    try:
+        integer_process = ServeProcess(
+            integer_backend,
+            command_for(integer_backend, engine_args, serve=True),
+            args.startup_timeout,
+        )
+        for iteration in range(args.iterations):
+            for prompt in prompts:
+                generated, seconds, tokens = integer_process.request(
+                    prompt, args.request_timeout
+                )
+                integer_rows.append(
+                    {
+                        "iteration": iteration,
+                        "prompt": prompt.name,
+                        "generated": generated,
+                        "seconds": seconds,
+                        "tokens": tokens,
+                    }
+                )
+    finally:
+        if integer_process is not None:
+            integer_process.close()
+    assert integer_process is not None
+
+    llama: LlamaServer | None = None
+    try:
+        llama = LlamaServer(args)
+        for iteration in range(args.iterations):
+            for prompt in prompts:
+                result = llama.complete(prompt, args)
+                fp_rows.append(
+                    {
+                        "iteration": iteration,
+                        "prompt": prompt.name,
+                        **result,
+                    }
+                )
+    finally:
+        if llama is not None:
+            llama.terminate()
+    assert llama is not None
+
+    failures = runtime_drift(integer_rows, prompt_names, "canonical-integer-metal-v3")
+    failures.extend(runtime_drift(fp_rows, prompt_names, "llama.cpp-fp-metal"))
+    artifacts = {
+        "runner": artifact_record(Path(__file__).resolve()),
+        "soak_library": artifact_record(Path(__file__).resolve().with_name("qi35_soak.py")),
+        "engine": artifact_record(args.engine),
+        "engine_libraries": [artifact_record(path) for path in args.engine_library],
+        "engine_source": artifact_record(args.source),
+        "tables": artifact_record(args.tables),
+        "model": artifact_record(args.model),
+        "tokenizer": artifact_record(args.tokenizer),
+        "corpus": artifact_record(args.corpus),
+        "llama_server": artifact_record(args.llama_server),
+        "llama_libraries": [artifact_record(path) for path in args.llama_library],
+        "llama_patch": artifact_record(args.llama_patch),
+    }
+    return {
+        "schema": SCHEMA,
+        "started_at_utc": started_at,
+        "finished_at_utc": utc_now(),
+        "measurement_complete": not failures,
+        "host": host_record(),
+        "configuration": {
+            "iterations": args.iterations,
+            "max_new": args.max_new,
+            "threads": args.threads,
+            "context_size": args.context_size,
+            "llama_gpu_layers": args.llama_gpu_layers,
+            "engine_library_count": len(args.engine_library),
+            "llama_library_count": len(args.llama_library),
+            "llama_revision": args.llama_revision,
+            "llama_transport": (
+                "runner-owned numeric-loopback HTTP; proxies and redirects disabled"
+            ),
+            "sampling": {
+                "temperature": 0.0,
+                "top_k": 0,
+                "top_p": 1.0,
+                "min_p": 0.0,
+                "repeat_penalty": 1.0,
+                "presence_penalty": 0.0,
+                "frequency_penalty": 0.0,
+                "dry_multiplier": 0.0,
+                "ignore_eos": True,
+                "cache_prompt": False,
+                "raw_token_input_output": True,
+            },
+            "prompts": corpus_entries,
+        },
+        "artifacts": artifacts,
+        "quality": quality_summary(integer_rows, fp_rows, prompt_names),
+        "integer_measurements": integer_rows,
+        "fp_measurements": fp_rows,
+        "integer_stderr_tail": list(integer_process.stderr_tail),
+        "llama_log_tail": list(llama.log_tail),
+        "failures": failures,
+    }
+
+
+def main() -> int:
+    args = parse_args()
+    try:
+        report = run(args)
+        write_new_json(args.output, report)
+    except (OSError, ValueError, json.JSONDecodeError, SoakError) as error:
+        print(f"qi35-calibrate: ERROR: {error}", file=sys.stderr)
+        return 2
+    quality = report["quality"]
+    status = "COMPLETE" if report["measurement_complete"] else "NONDETERMINISTIC"
+    print(
+        f"qi35-calibrate: {status}; identical_prompts="
+        f"{quality['fully_identical_prompts']}/{quality['prompt_count']} "
+        f"prefix_tokens={quality['prefix_match_tokens']}/{quality['compared_tokens']}"
+    )
+    print(f"report: {args.output}")
+    return 0 if report["measurement_complete"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/qi35_fp_probe.py b/scripts/qi35_fp_probe.py
new file mode 100644
index 0000000000000000000000000000000000000000..702331a3a428e043f17c286ca1ec9c5b2c41a7b1
--- /dev/null
+++ b/scripts/qi35_fp_probe.py
@@ -0,0 +1,912 @@
+#!/usr/bin/env python3
+"""Launch and attest a pinned CUDA llama-server against QI35 integer evidence."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import signal
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any, Iterable
+
+try:
+    from scripts.qi35_calibrate import (
+        SCHEMA as REFERENCE_SCHEMA,
+        LEGACY_UNATTESTED_SCHEMA as LEGACY_REFERENCE_SCHEMA,
+        clean_llama_environment,
+        close_http_error,
+        direct_http_opener,
+        free_local_port,
+        load_corpus,
+        quality_summary,
+        runtime_drift,
+    )
+    from scripts.qi35_soak import (
+        Prompt,
+        SoakError,
+        artifact_record,
+        host_record,
+        utc_now,
+        write_new_json,
+    )
+except ModuleNotFoundError:  # Direct execution from the scripts directory.
+    from qi35_calibrate import (  # type: ignore[no-redef]
+        SCHEMA as REFERENCE_SCHEMA,
+        LEGACY_UNATTESTED_SCHEMA as LEGACY_REFERENCE_SCHEMA,
+        clean_llama_environment,
+        close_http_error,
+        direct_http_opener,
+        free_local_port,
+        load_corpus,
+        quality_summary,
+        runtime_drift,
+    )
+    from qi35_soak import (  # type: ignore[no-redef]
+        Prompt,
+        SoakError,
+        artifact_record,
+        host_record,
+        utc_now,
+        write_new_json,
+    )
+
+
+SCHEMA = "misaka.qi35.fp-cross-host-probe.v2"
+LEGACY_UNATTESTED_SCHEMA = "misaka.qi35.fp-cross-host-probe.v1"
+ATTESTATION_SCHEMA = "misaka.qi35.runner-owned-cuda-server-attestation.v1"
+MATCHED_ARTIFACTS = ("model", "tokenizer", "corpus", "llama_patch")
+CUDA_LIBRARY_RE = re.compile(r"^libggml-cuda\.so(?:\..*)?$")
+SHARED_LIBRARY_RE = re.compile(r"^.+\.so(?:\..*)?$")
+RUNTIME_RELEVANT_LIBRARY_RE = re.compile(
+    r"^(?:libllama(?:-[^.]+)?|libggml(?:-[^.]+)?|libmtmd|libcuda|libcudart|"
+    r"libcublas(?:Lt)?)\.so(?:\..*)?$"
+)
+CUDA_DEVICE_LOG_RE = re.compile(r"\bggml_cuda_init: found ([1-9][0-9]*) CUDA devices?\b")
+CUDA_DEVICE_INFO_LOG_RE = re.compile(
+    r"\b(?:common_param:\s+-\s+CUDA|common_params_print_info:\s+device_info:\s+-\s+CUDA)"
+    r"([0-9]+)\s*:"
+)
+FULL_OFFLOAD_LOG_RE = re.compile(
+    r"\b(?:load_tensors|llm_load_tensors): offloaded ([0-9]+)/([0-9]+) layers to GPU\b"
+)
+BUILD_REVISION_LOG_RE = re.compile(
+    r"\bbuild(?:\s*=)?\s+[0-9]+\s+\(([0-9a-fA-F]{7,40})\)"
+)
+SERVER_ENVIRONMENT_PREFIXES = ("CUDA_", "GGML_", "LLAMA_ARG_", "NVIDIA_", "PALW_", "QI35_")
+LOADER_ENVIRONMENT_KEYS = {
+    "DYLD_INSERT_LIBRARIES",
+    "DYLD_LIBRARY_PATH",
+    "LD_LIBRARY_PATH",
+    "LD_PRELOAD",
+}
+
+
+def local_server_url(raw: str) -> str:
+    """Accept only an unauthenticated numeric-loopback HTTP origin."""
+    parsed = urllib.parse.urlsplit(raw)
+    if (
+        parsed.scheme != "http"
+        or parsed.hostname not in {"127.0.0.1", "::1"}
+        or parsed.username is not None
+        or parsed.password is not None
+        or parsed.query
+        or parsed.fragment
+        or parsed.path not in {"", "/"}
+        or parsed.port is None
+    ):
+        raise argparse.ArgumentTypeError(
+            "server origin must be an unauthenticated numeric-loopback HTTP origin "
+            "with an explicit port"
+        )
+    return raw.rstrip("/")
+
+
+def complete(
+    server_url: str,
+    prompt: Prompt,
+    max_new: int,
+    request_timeout: float,
+    opener: urllib.request.OpenerDirector | None = None,
+) -> dict[str, Any]:
+    body = {
+        "prompt": list(prompt.ids),
+        "n_predict": max_new,
+        "return_tokens": True,
+        "temperature": 0.0,
+        "top_k": 0,
+        "top_p": 1.0,
+        "min_p": 0.0,
+        "repeat_penalty": 1.0,
+        "presence_penalty": 0.0,
+        "frequency_penalty": 0.0,
+        "dry_multiplier": 0.0,
+        "cache_prompt": False,
+        "ignore_eos": True,
+        "seed": 0,
+    }
+    request = urllib.request.Request(
+        f"{server_url}/completion",
+        data=json.dumps(body).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    direct_opener = opener or direct_http_opener()
+    try:
+        with direct_opener.open(request, timeout=request_timeout) as response:
+            result = json.load(response)
+    except (OSError, urllib.error.URLError, json.JSONDecodeError) as error:
+        close_http_error(error)
+        raise SoakError(f"llama-server request failed for {prompt.name!r}") from error
+    if not isinstance(result, dict):
+        raise SoakError(f"llama-server returned a non-object for {prompt.name!r}")
+    tokens = result.get("tokens")
+    if not isinstance(tokens, list) or not all(type(value) is int for value in tokens):
+        raise SoakError(f"llama-server omitted raw tokens for {prompt.name!r}")
+    if len(tokens) != max_new:
+        raise SoakError(
+            f"llama-server returned {len(tokens)} tokens for {prompt.name!r}, expected {max_new}"
+        )
+    timings = result.get("timings", {})
+    if not isinstance(timings, dict):
+        raise SoakError(f"llama-server returned malformed timings for {prompt.name!r}")
+    return {
+        "generated": tokens,
+        "stop_type": result.get("stop_type"),
+        "predicted_ms": timings.get("predicted_ms"),
+        "predicted_per_second": timings.get("predicted_per_second"),
+        "prompt_ms": timings.get("prompt_ms"),
+        "tokens_cached": result.get("tokens_cached"),
+    }
+
+
+def clean_server_environment(library_dir: Path) -> dict[str, str]:
+    """Build a deterministic server environment with one explicit loader directory."""
+    inherited = clean_llama_environment()
+    environment = {
+        key: value
+        for key, value in inherited.items()
+        if key not in LOADER_ENVIRONMENT_KEYS
+        and not key.startswith(SERVER_ENVIRONMENT_PREFIXES)
+    }
+    environment.update(
+        {
+            "LANG": "C",
+            "LC_ALL": "C",
+            "LD_LIBRARY_PATH": str(library_dir.resolve()),
+        }
+    )
+    return environment
+
+
+def server_command(args: argparse.Namespace, port: int) -> list[str]:
+    """Return the complete runner-owned server command."""
+    return [
+        str(args.server_binary),
+        "-m",
+        str(args.model),
+        "-c",
+        str(args.context_size),
+        "-np",
+        "1",
+        "-ngl",
+        "all",
+        "--host",
+        "127.0.0.1",
+        "--port",
+        str(port),
+        "--no-webui",
+        "--no-warmup",
+        "--log-verbosity",
+        "4",
+    ]
+
+
+def proc_mapped_files(pid: int) -> list[Path]:
+    """Return unique, live absolute file mappings for a same-user Linux process."""
+    try:
+        lines = Path(f"/proc/{pid}/maps").read_text(encoding="utf-8").splitlines()
+    except OSError as error:
+        raise SoakError("cannot inspect runner-owned server memory mappings") from error
+    paths: dict[tuple[int, int], Path] = {}
+    for line in lines:
+        fields = line.split(None, 5)
+        if len(fields) != 6:
+            continue
+        raw_path = fields[5]
+        if not raw_path.startswith("/") or raw_path.endswith(" (deleted)"):
+            continue
+        try:
+            resolved = Path(raw_path).resolve(strict=True)
+        except OSError:
+            continue
+        if resolved.is_file():
+            try:
+                stat = resolved.stat()
+            except OSError:
+                continue
+            paths[(stat.st_dev, stat.st_ino)] = resolved
+    return list(paths.values())
+
+
+def proc_command(pid: int) -> list[str]:
+    try:
+        raw = Path(f"/proc/{pid}/cmdline").read_bytes()
+    except OSError as error:
+        raise SoakError("cannot inspect runner-owned server command line") from error
+    return [part.decode("utf-8", errors="surrogateescape") for part in raw.split(b"\0") if part]
+
+
+def proc_owns_ipv4_listener(pid: int, port: int) -> bool:
+    """Return whether the process owns the 127.0.0.1 listening socket for port."""
+    socket_inodes: set[str] = set()
+    try:
+        for descriptor in Path(f"/proc/{pid}/fd").iterdir():
+            try:
+                target = os.readlink(descriptor)
+            except OSError:
+                continue
+            match = re.fullmatch(r"socket:\[([0-9]+)\]", target)
+            if match is not None:
+                socket_inodes.add(match.group(1))
+        tcp_lines = Path(f"/proc/{pid}/net/tcp").read_text(encoding="ascii").splitlines()[1:]
+    except OSError as error:
+        raise SoakError("cannot inspect runner-owned server listener") from error
+    expected_local = f"0100007F:{port:04X}"
+    for line in tcp_lines:
+        fields = line.split()
+        if (
+            len(fields) > 9
+            and fields[1] == expected_local
+            and fields[3] == "0A"
+            and fields[9] in socket_inodes
+        ):
+            return True
+    return False
+
+
+def proc_has_mapped_file(pid: int, expected_path: Path) -> bool:
+    expected = expected_path.resolve(strict=True)
+    for mapped in proc_mapped_files(pid):
+        try:
+            if os.path.samefile(expected, mapped):
+                return True
+        except OSError:
+            continue
+    return False
+
+
+def proc_environment(pid: int) -> dict[str, str]:
+    try:
+        raw = Path(f"/proc/{pid}/environ").read_bytes()
+    except OSError as error:
+        raise SoakError("cannot inspect runner-owned server environment") from error
+    result: dict[str, str] = {}
+    for entry in raw.split(b"\0"):
+        key, separator, value = entry.partition(b"=")
+        if separator:
+            result[key.decode("utf-8", errors="surrogateescape")] = value.decode(
+                "utf-8", errors="surrogateescape"
+            )
+    return result
+
+
+def is_runtime_relevant_mapping(path: Path, library_dir: Path) -> bool:
+    """Classify non-system mappings whose identity must be declared."""
+    try:
+        resolved_path = path.resolve(strict=True)
+        under_library_dir = resolved_path.is_relative_to(library_dir)
+    except (OSError, ValueError):
+        under_library_dir = False
+        resolved_path = path
+    return (
+        under_library_dir and SHARED_LIBRARY_RE.fullmatch(resolved_path.name) is not None
+    ) or RUNTIME_RELEVANT_LIBRARY_RE.fullmatch(resolved_path.name) is not None
+
+
+def bind_declared_libraries(
+    pid: int,
+    declared_paths: list[Path],
+    library_dir: Path,
+) -> list[dict[str, Any]]:
+    """Bind a complete declared runtime DSO set to identical live mappings."""
+    mapped_paths = proc_mapped_files(pid)
+    resolved_library_dir = library_dir.resolve(strict=True)
+
+    bindings: list[dict[str, Any]] = []
+    for declared_path in declared_paths:
+        declared = declared_path.resolve(strict=True)
+        mapped: Path | None = None
+        for candidate in mapped_paths:
+            try:
+                if os.path.samefile(declared, candidate):
+                    mapped = candidate
+                    break
+            except OSError:
+                continue
+        if mapped is None:
+            raise SoakError(
+                f"declared server library was not loaded: {declared_path.name}"
+            )
+        mapped_record = artifact_record(mapped)
+        declared_record = {
+            **mapped_record,
+            "basename": declared.name,
+        }
+        bindings.append(
+            {
+                "declared": declared_record,
+                "mapped_basename": mapped_record["basename"],
+                "mapped_bytes": mapped_record["bytes"],
+                "mapped_sha256": mapped_record["sha256"],
+                "runtime_relevant": is_runtime_relevant_mapping(
+                    mapped,
+                    resolved_library_dir,
+                ),
+            }
+        )
+
+    undeclared: list[str] = []
+    for mapped in mapped_paths:
+        if not is_runtime_relevant_mapping(mapped, resolved_library_dir):
+            continue
+        if not any(
+            _same_file(mapped, declared) for declared in declared_paths
+        ):
+            undeclared.append(mapped.name)
+    if undeclared:
+        raise SoakError(
+            "runtime-relevant mapped library was not declared: "
+            + ", ".join(sorted(set(undeclared)))
+        )
+    return bindings
+
+
+def _same_file(first: Path, second: Path) -> bool:
+    try:
+        return os.path.samefile(first, second)
+    except OSError:
+        return False
+
+
+def cuda_log_attestation(
+    lines: list[str],
+    expected_revision: str,
+) -> dict[str, Any]:
+    """Extract non-sensitive CUDA and full-offload facts from server startup logs."""
+    log = "\n".join(lines)
+    init_device_counts = [int(value) for value in CUDA_DEVICE_LOG_RE.findall(log)]
+    device_indices = sorted({int(value) for value in CUDA_DEVICE_INFO_LOG_RE.findall(log)})
+    if device_indices and device_indices != list(range(len(device_indices))):
+        raise SoakError("server log reported a non-contiguous CUDA device inventory")
+    info_device_count = len(device_indices)
+    if init_device_counts and info_device_count and init_device_counts[-1] != info_device_count:
+        raise SoakError("server CUDA initialization and device inventory counts disagree")
+    cuda_device_count = init_device_counts[-1] if init_device_counts else info_device_count
+    if cuda_device_count == 0:
+        raise SoakError("server log did not prove CUDA backend initialization")
+    offload_counts = [
+        (int(offloaded), int(total))
+        for offloaded, total in FULL_OFFLOAD_LOG_RE.findall(log)
+    ]
+    if not offload_counts:
+        raise SoakError("server log did not report GPU layer offload")
+    offloaded, total = offload_counts[-1]
+    if total <= 0 or offloaded != total:
+        raise SoakError(f"server did not fully offload model layers ({offloaded}/{total})")
+    revisions = BUILD_REVISION_LOG_RE.findall(log)
+    if not revisions:
+        raise SoakError("server log did not bind the llama.cpp build revision")
+    logged_revision = revisions[-1].lower()
+    if not expected_revision.lower().startswith(logged_revision):
+        raise SoakError("server build revision differs from --llama-revision")
+    return {
+        "build_revision": logged_revision,
+        "cuda_device_count": cuda_device_count,
+        "gpu_layers_requested": "all",
+        "offloaded_layers": offloaded,
+        "total_offloadable_layers": total,
+        "full_gpu_layer_offload": True,
+    }
+
+
+class RunnerOwnedLlamaServer:
+    """Own, directly query, attest, and stop one pinned llama-server process."""
+
+    def __init__(self, args: argparse.Namespace, accelerators: list[dict[str, str]]) -> None:
+        if not sys.platform.startswith("linux") or not Path("/proc/self/maps").is_file():
+            raise SoakError("cross-host CUDA attestation requires Linux /proc")
+        self.port = free_local_port()
+        self.url = local_server_url(f"http://127.0.0.1:{self.port}")
+        self.opener = direct_http_opener()
+        self.command = server_command(args, self.port)
+        self.log_lines: list[str] = []
+        self.log_lock = threading.Lock()
+        self.process: subprocess.Popen[str] | None = None
+        try:
+            self.process = subprocess.Popen(
+                self.command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                bufsize=1,
+                env=clean_server_environment(args.server_library_dir),
+                start_new_session=True,
+            )
+            assert self.process.stdout is not None
+            assert self.process.stderr is not None
+            threading.Thread(target=self._drain, args=(self.process.stdout,), daemon=True).start()
+            threading.Thread(target=self._drain, args=(self.process.stderr,), daemon=True).start()
+            self._wait_ready(args.startup_timeout)
+            log_attestation = self._wait_for_log_attestation(
+                args.llama_revision, min(15.0, args.startup_timeout)
+            )
+            self.attestation = self._attest_process(
+                args,
+                accelerators,
+                log_attestation,
+            )
+        except BaseException:
+            self.terminate()
+            raise
+
+    def _drain(self, stream: Iterable[str]) -> None:
+        for line in stream:
+            with self.log_lock:
+                self.log_lines.append(line.rstrip("\n"))
+
+    def _snapshot_logs(self) -> list[str]:
+        with self.log_lock:
+            return list(self.log_lines)
+
+    def _wait_ready(self, timeout: float) -> None:
+        assert self.process is not None
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if self.process.poll() is not None:
+                raise SoakError(
+                    f"runner-owned llama-server exited during startup ({self.process.returncode})"
+                )
+            try:
+                with self.opener.open(f"{self.url}/health", timeout=1) as response:
+                    if response.status == 200:
+                        return
+            except (OSError, urllib.error.URLError) as error:
+                close_http_error(error)
+                pass
+            time.sleep(0.2)
+        raise SoakError("runner-owned llama-server startup timed out")
+
+    def _wait_for_log_attestation(
+        self,
+        expected_revision: str,
+        timeout: float,
+    ) -> dict[str, Any]:
+        assert self.process is not None
+        deadline = time.monotonic() + timeout
+        last_error: SoakError | None = None
+        while time.monotonic() < deadline:
+            if self.process.poll() is not None:
+                raise SoakError("runner-owned llama-server exited before attestation")
+            try:
+                return cuda_log_attestation(self._snapshot_logs(), expected_revision)
+            except SoakError as error:
+                last_error = error
+                time.sleep(0.05)
+        detail = str(last_error) if last_error is not None else "no startup log was captured"
+        raise SoakError(f"server startup log attestation timed out: {detail}") from last_error
+
+    def _attest_process(
+        self,
+        args: argparse.Namespace,
+        accelerators: list[dict[str, str]],
+        log_attestation: dict[str, Any],
+    ) -> dict[str, Any]:
+        assert self.process is not None
+        pid = self.process.pid
+        try:
+            proc_executable = Path(f"/proc/{pid}/exe").resolve(strict=True)
+        except OSError as error:
+            raise SoakError("cannot inspect runner-owned server executable") from error
+        if not os.path.samefile(proc_executable, args.server_binary):
+            raise SoakError("runner-owned process executable differs from --server-binary")
+        if proc_command(pid) != self.command:
+            raise SoakError("runner-owned process command line changed before attestation")
+        if not proc_owns_ipv4_listener(pid, self.port):
+            raise SoakError("runner-owned process does not own the loopback listener")
+        if not proc_has_mapped_file(pid, args.model):
+            raise SoakError("runner-owned process did not map the declared model")
+        environment = proc_environment(pid)
+        expected_library_dir = str(args.server_library_dir.resolve())
+        if environment.get("LD_LIBRARY_PATH") != expected_library_dir:
+            raise SoakError("runner-owned process loader directory differs from declaration")
+        bindings = bind_declared_libraries(
+            pid,
+            args.server_library,
+            args.server_library_dir,
+        )
+        cuda_bindings = [
+            binding
+            for binding in bindings
+            if CUDA_LIBRARY_RE.fullmatch(binding["declared"]["basename"])
+        ]
+        if not cuda_bindings:
+            raise SoakError("declared and loaded runtime has no libggml-cuda DSO")
+        if log_attestation["cuda_device_count"] != len(accelerators):
+            raise SoakError(
+                "CUDA device count in server log differs from nvidia-smi inventory"
+            )
+        logs = self._snapshot_logs()
+        log_bytes = ("\n".join(logs) + "\n").encode("utf-8")
+        return {
+            "schema": ATTESTATION_SCHEMA,
+            "runner_owned_process": True,
+            "transport": {
+                "http_proxy": "disabled",
+                "http_redirects": "disabled",
+                "numeric_loopback": "127.0.0.1",
+            },
+            "process": {
+                "proc_cmdline_match": True,
+                "proc_exe_match": True,
+                "proc_model_mapping_match": True,
+                "proc_numeric_loopback_listener_match": True,
+                "executable": artifact_record(proc_executable),
+                "loader_environment_match": True,
+                "loader_path_stored": False,
+            },
+            "runtime_libraries": {
+                "all_declared_loaded": True,
+                "all_runtime_relevant_mappings_declared": True,
+                "declared_count": len(bindings),
+                "loaded_binding_count": len(bindings),
+                "runtime_relevant_mapping_count": sum(
+                    bool(binding["runtime_relevant"])
+                    for binding in bindings
+                ),
+                "bindings": bindings,
+                "libggml_cuda": cuda_bindings[0]["declared"],
+            },
+            "cuda": {
+                **log_attestation,
+                "accelerator_inventory_count": len(accelerators),
+            },
+            "startup_log": {
+                "line_count": len(logs),
+                "sha256": hashlib.sha256(log_bytes).hexdigest(),
+                "stored_verbatim": False,
+            },
+        }
+
+    def terminate(self) -> None:
+        if self.process is None or self.process.poll() is not None:
+            return
+        try:
+            os.killpg(self.process.pid, signal.SIGTERM)
+            self.process.wait(timeout=15)
+        except (ProcessLookupError, subprocess.TimeoutExpired):
+            if self.process.poll() is None:
+                self.process.kill()
+                self.process.wait(timeout=5)
+
+
+def inventory_environment() -> dict[str, str]:
+    """Return the complete deterministic environment for accelerator inventory."""
+    return {"LANG": "C", "LC_ALL": "C"}
+
+
+def gpu_record(executable: Path) -> list[dict[str, str]]:
+    """Record non-unique NVIDIA device facts without serials or UUIDs."""
+    fields = ("name", "compute_cap", "memory.total", "driver_version")
+    try:
+        result = subprocess.run(
+            [
+                str(executable.resolve(strict=True)),
+                f"--query-gpu={','.join(fields)}",
+                "--format=csv,noheader,nounits",
+            ],
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            env=inventory_environment(),
+            timeout=15,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return []
+    if result.returncode != 0:
+        return []
+    devices: list[dict[str, str]] = []
+    for line in result.stdout.splitlines():
+        values = [value.strip() for value in line.split(",")]
+        if len(values) == len(fields):
+            devices.append(dict(zip(fields, values, strict=True)))
+    return devices
+
+
+def read_reference(
+    path: Path,
+    prompt_names: list[str],
+    iterations: int,
+    max_new: int,
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    try:
+        report = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise SoakError(f"cannot read reference calibration {path}") from error
+    if report.get("schema") == LEGACY_REFERENCE_SCHEMA:
+        raise SoakError(
+            "reference calibration uses legacy v1 without canonical-engine runtime "
+            "library provenance; recapture it with the v2 runner"
+        )
+    if report.get("schema") != REFERENCE_SCHEMA or report.get("measurement_complete") is not True:
+        raise SoakError("reference calibration is incomplete or has the wrong schema")
+    configuration = report.get("configuration")
+    if not isinstance(configuration, dict):
+        raise SoakError("reference calibration has no configuration")
+    if configuration.get("iterations") != iterations or configuration.get("max_new") != max_new:
+        raise SoakError("reference calibration iteration/token counts do not match this probe")
+    rows = report.get("integer_measurements")
+    if not isinstance(rows, list):
+        raise SoakError("reference calibration has no integer measurements")
+    expected_pairs = [
+        (iteration, prompt_name)
+        for iteration in range(iterations)
+        for prompt_name in prompt_names
+    ]
+    actual_pairs: list[tuple[int, str]] = []
+    for row in rows:
+        if not isinstance(row, dict):
+            raise SoakError("reference integer measurement is not an object")
+        generated = row.get("generated")
+        if (
+            not isinstance(row.get("iteration"), int)
+            or not isinstance(row.get("prompt"), str)
+            or not isinstance(generated, list)
+            or len(generated) != max_new
+            or not all(type(value) is int for value in generated)
+        ):
+            raise SoakError("reference integer measurement is malformed")
+        actual_pairs.append((row["iteration"], row["prompt"]))
+    if actual_pairs != expected_pairs:
+        raise SoakError("reference integer measurement order or coverage is incomplete")
+    if runtime_drift(rows, prompt_names, "reference-canonical-integer"):
+        raise SoakError("reference canonical-integer runtime was nondeterministic")
+    return report, rows
+
+
+def verify_artifact_identity(
+    reference: dict[str, Any],
+    artifacts: dict[str, Any],
+) -> None:
+    expected = reference.get("artifacts")
+    if not isinstance(expected, dict):
+        raise SoakError("reference calibration has no artifact records")
+    for name in MATCHED_ARTIFACTS:
+        expected_record = expected.get(name)
+        if not isinstance(expected_record, dict):
+            raise SoakError(f"reference calibration has no {name} artifact")
+        for field in ("sha256", "bytes"):
+            if artifacts[name].get(field) != expected_record.get(field):
+                raise SoakError(f"{name} artifact differs from reference calibration")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--nvidia-smi",
+        required=True,
+        type=Path,
+        help="Exact nvidia-smi executable used for the accelerator inventory",
+    )
+    parser.add_argument("--server-binary", required=True, type=Path)
+    parser.add_argument(
+        "--server-library-dir",
+        required=True,
+        type=Path,
+        help="Exact directory exported as the server's only LD_LIBRARY_PATH entry",
+    )
+    parser.add_argument(
+        "--server-library",
+        action="append",
+        required=True,
+        type=Path,
+        help="Loaded llama/ggml shared library; repeat for every non-system runtime library",
+    )
+    parser.add_argument("--model", required=True, type=Path)
+    parser.add_argument("--tokenizer", required=True, type=Path)
+    parser.add_argument("--corpus", required=True, type=Path)
+    parser.add_argument("--llama-patch", required=True, type=Path)
+    parser.add_argument("--llama-revision", required=True)
+    parser.add_argument("--reference-calibration", required=True, type=Path)
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument("--iterations", type=int, default=3)
+    parser.add_argument("--max-new", type=int, default=8)
+    parser.add_argument("--vocab-size", type=int, default=248_320)
+    parser.add_argument("--context-size", type=int, default=1024)
+    parser.add_argument("--startup-timeout", type=float, default=300.0)
+    parser.add_argument("--request-timeout", type=float, default=300.0)
+    args = parser.parse_args()
+    if not args.server_library_dir.is_dir():
+        parser.error("--server-library-dir is not a directory")
+    for name in (
+        "nvidia_smi",
+        "server_binary",
+        "model",
+        "tokenizer",
+        "corpus",
+        "llama_patch",
+        "reference_calibration",
+    ):
+        if not getattr(args, name).is_file():
+            parser.error(f"--{name.replace('_', '-')} is not a file")
+    for name in ("nvidia_smi", "server_binary"):
+        if not os.access(getattr(args, name), os.X_OK):
+            parser.error(f"--{name.replace('_', '-')} is not executable")
+    for library in args.server_library:
+        if not library.is_file():
+            parser.error(f"--server-library is not a file: {library}")
+    if len({library.resolve() for library in args.server_library}) != len(args.server_library):
+        parser.error("--server-library entries must be unique")
+    if not any(CUDA_LIBRARY_RE.fullmatch(path.name) for path in args.server_library):
+        parser.error("--server-library must include libggml-cuda.so")
+    for name in ("iterations", "max_new", "vocab_size", "context_size"):
+        if getattr(args, name) <= 0:
+            parser.error(f"--{name.replace('_', '-')} must be positive")
+    for name in ("startup_timeout", "request_timeout"):
+        if getattr(args, name) <= 0:
+            parser.error(f"--{name.replace('_', '-')} must be positive")
+    if not re.fullmatch(r"[0-9a-fA-F]{40}", args.llama_revision):
+        parser.error("--llama-revision must be a full 40-hex commit id")
+    for name in (
+        "nvidia_smi",
+        "server_binary",
+        "server_library_dir",
+        "model",
+        "tokenizer",
+        "corpus",
+        "llama_patch",
+        "reference_calibration",
+    ):
+        setattr(args, name, getattr(args, name).resolve())
+    args.server_library = [path.resolve() for path in args.server_library]
+    return args
+
+
+def run(args: argparse.Namespace) -> dict[str, Any]:
+    prompts, corpus_entries = load_corpus(args.corpus, args.tokenizer, args.vocab_size)
+    prompt_names = [prompt.name for prompt in prompts]
+    reference, integer_rows = read_reference(
+        args.reference_calibration,
+        prompt_names,
+        args.iterations,
+        args.max_new,
+    )
+    artifacts = {
+        "runner": artifact_record(Path(__file__).resolve()),
+        "calibration_library": artifact_record(
+            Path(__file__).resolve().with_name("qi35_calibrate.py")
+        ),
+        "soak_library": artifact_record(Path(__file__).resolve().with_name("qi35_soak.py")),
+        "server_binary": artifact_record(args.server_binary),
+        "nvidia_smi": artifact_record(args.nvidia_smi),
+        "model": artifact_record(args.model),
+        "tokenizer": artifact_record(args.tokenizer),
+        "corpus": artifact_record(args.corpus),
+        "llama_patch": artifact_record(args.llama_patch),
+        "reference_calibration": artifact_record(args.reference_calibration),
+    }
+    verify_artifact_identity(reference, artifacts)
+    if reference.get("configuration", {}).get("llama_revision") != args.llama_revision:
+        raise SoakError("llama.cpp revision differs from reference calibration")
+
+    accelerators = gpu_record(args.nvidia_smi)
+    if not accelerators:
+        raise SoakError("nvidia-smi did not report an NVIDIA accelerator")
+
+    started_at = utc_now()
+    fp_rows: list[dict[str, Any]] = []
+    server: RunnerOwnedLlamaServer | None = None
+    try:
+        server = RunnerOwnedLlamaServer(args, accelerators)
+        for iteration in range(args.iterations):
+            for prompt in prompts:
+                fp_rows.append(
+                    {
+                        "iteration": iteration,
+                        "prompt": prompt.name,
+                        **complete(
+                            server.url,
+                            prompt,
+                            args.max_new,
+                            args.request_timeout,
+                            server.opener,
+                        ),
+                    }
+                )
+        attestation = server.attestation
+        server_origin = server.url
+        artifacts["server_libraries"] = [
+            binding["declared"]
+            for binding in attestation["runtime_libraries"]["bindings"]
+        ]
+    finally:
+        if server is not None:
+            server.terminate()
+    failures = runtime_drift(fp_rows, prompt_names, "llama.cpp-fp-cross-host")
+    return {
+        "schema": SCHEMA,
+        "started_at_utc": started_at,
+        "finished_at_utc": utc_now(),
+        "measurement_complete": not failures,
+        "host": host_record(),
+        "accelerators": accelerators,
+        "configuration": {
+            "context_size": args.context_size,
+            "iterations": args.iterations,
+            "max_new": args.max_new,
+            "runner_owned_server": True,
+            "accelerator_inventory": (
+                "explicit content-addressed nvidia-smi; inherited environment scrubbed"
+            ),
+            "server_library_count": len(args.server_library),
+            "server_library_directory": "proc-verified; path not stored",
+            "llama_revision": args.llama_revision,
+            "server_origin": server_origin,
+            "server_transport": (
+                "direct numeric-loopback HTTP; proxies and redirects disabled"
+            ),
+            "gpu_layers": "all",
+            "server_log_verbosity": "trace (raw log hashed, not stored)",
+            "sampling": reference["configuration"]["sampling"],
+            "prompts": corpus_entries,
+        },
+        "artifacts": artifacts,
+        "server_attestation": attestation,
+        "reference": {
+            "host": reference.get("host"),
+            "artifacts": reference.get("artifacts"),
+        },
+        "quality": quality_summary(integer_rows, fp_rows, prompt_names),
+        "fp_measurements": fp_rows,
+        "failures": failures,
+        "scope": (
+            "Cross-host floating-point CUDA calibration only; this does not claim a "
+            "canonical-integer CUDA backend."
+        ),
+    }
+
+
+def main() -> int:
+    args = parse_args()
+    try:
+        report = run(args)
+        write_new_json(args.output, report)
+    except (OSError, ValueError, json.JSONDecodeError, SoakError) as error:
+        print(f"qi35-fp-probe: ERROR: {error}", file=sys.stderr)
+        return 2
+    quality = report["quality"]
+    status = "COMPLETE" if report["measurement_complete"] else "NONDETERMINISTIC"
+    print(
+        f"qi35-fp-probe: {status}; identical_prompts="
+        f"{quality['fully_identical_prompts']}/{quality['prompt_count']} "
+        f"prefix_tokens={quality['prefix_match_tokens']}/{quality['compared_tokens']}"
+    )
+    print(f"report: {args.output}")
+    return 0 if report["measurement_complete"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/qi35_soak.py b/scripts/qi35_soak.py
new file mode 100644
index 0000000000000000000000000000000000000000..e474ac0303e09c68fe3c05596a3377b678b960ca
--- /dev/null
+++ b/scripts/qi35_soak.py
@@ -0,0 +1,1011 @@
+#!/usr/bin/env python3
+"""Run a deterministic QI35 soak across two or more execution backends.
+
+The runner keeps each backend process alive in ``--serve`` mode, rotates a
+fixed prompt schedule, checks reset determinism, and compares every generated
+token sequence.  A one-shot run also compares the execution roots, which the
+current serve protocol does not expose.
+
+No shell is involved.  Inherited ``QI35_*`` variables are removed so a caller
+cannot accidentally turn a calibration knob without recording it in a backend
+configuration. Reports also bind the runner, backend plan, and an explicit
+manifest (including an explicit empty declaration) of non-system runtime DSOs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import dataclasses
+import datetime as dt
+import hashlib
+import json
+import os
+import platform
+import queue
+import re
+import shutil
+import signal
+import statistics
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from collections import deque
+from pathlib import Path
+from typing import Any, Iterable
+
+
+SCHEMA = "misaka.qi35.hardware-soak.v2"
+LEGACY_UNATTESTED_SCHEMA = "misaka.qi35.hardware-soak.v1"
+PLAN_SCHEMA = "misaka.qi35.soak-plan.v1"
+NAME_RE = re.compile(r"^[a-z0-9][a-z0-9._-]{0,63}$")
+DONE_RE = re.compile(r"^DONE ([0-9]+(?:\.[0-9]+)?)s ([0-9]+)tok$")
+HEX_32_RE = r"([0-9a-f]{64})"
+ROOT_PATTERNS = {
+    "route_root": re.compile(rf"^route_root = {HEX_32_RE}$", re.MULTILINE),
+    "kv_root": re.compile(rf"^kv_root = {HEX_32_RE}$", re.MULTILINE),
+    "state_root": re.compile(rf"^state_root = {HEX_32_RE}$", re.MULTILINE),
+}
+SENSITIVE_ENV_RE = re.compile(r"(?:KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL)", re.I)
+DEFAULT_PROMPTS = (
+    "hello=9419,11,1814",
+    "paris=760,6511,314,9338,369",
+)
+
+
+class SoakError(RuntimeError):
+    """An input, subprocess, or protocol error that invalidates the run."""
+
+
+@dataclasses.dataclass(frozen=True)
+class Prompt:
+    name: str
+    ids: tuple[int, ...]
+
+
+@dataclasses.dataclass(frozen=True)
+class Backend:
+    name: str
+    executable: Path
+    flags: tuple[str, ...]
+    environment: dict[str, str]
+
+
+def utc_now() -> str:
+    return dt.datetime.now(dt.timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def parse_prompt_spec(spec: str, vocab_size: int) -> Prompt:
+    name, separator, raw_ids = spec.partition("=")
+    if not separator or not NAME_RE.fullmatch(name):
+        raise SoakError(f"invalid prompt specification {spec!r}; expected name=id,id")
+    try:
+        ids = tuple(int(value) for value in raw_ids.split(",") if value)
+    except ValueError as error:
+        raise SoakError(f"prompt {name!r} contains a non-integer token") from error
+    if not ids:
+        raise SoakError(f"prompt {name!r} is empty")
+    invalid = next((value for value in ids if value < 0 or value >= vocab_size), None)
+    if invalid is not None:
+        raise SoakError(
+            f"prompt {name!r} token {invalid} is outside [0, {vocab_size})"
+        )
+    return Prompt(name=name, ids=ids)
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        while chunk := source.read(8 * 1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def artifact_record(path: Path) -> dict[str, Any]:
+    stat = path.stat()
+    return {
+        "basename": path.name,
+        "bytes": stat.st_size,
+        "sha256": sha256_file(path),
+    }
+
+
+def clean_environment(overrides: dict[str, str]) -> dict[str, str]:
+    environment = {
+        key: value
+        for key, value in os.environ.items()
+        if not key.startswith("QI35_")
+    }
+    environment.update({"LC_ALL": "C", "LANG": "C"})
+    environment.update(overrides)
+    return environment
+
+
+def expand(value: str, variables: dict[str, str]) -> str:
+    try:
+        return value.format_map(variables)
+    except KeyError as error:
+        raise SoakError(f"unknown backend-plan placeholder {error.args[0]!r}") from error
+
+
+def load_backends(args: argparse.Namespace) -> list[Backend]:
+    variables = {
+        "engine": str(args.engine.resolve()),
+        "engine_dir": str(args.engine.resolve().parent),
+        "model": str(args.model.resolve()),
+        "tables": str(args.tables.resolve()),
+        "threads": str(args.threads),
+        "max_new": str(args.max_new),
+    }
+    if args.backend_config:
+        raw = json.loads(args.backend_config.read_text(encoding="utf-8"))
+        if raw.get("schema") != PLAN_SCHEMA:
+            raise SoakError(f"backend plan must use schema {PLAN_SCHEMA!r}")
+        entries = raw.get("backends")
+        if not isinstance(entries, list) or not entries:
+            raise SoakError("backend plan must contain a non-empty backends list")
+        backends: list[Backend] = []
+        for entry in entries:
+            if not isinstance(entry, dict):
+                raise SoakError("every backend-plan entry must be an object")
+            name = entry.get("name")
+            flags = entry.get("flags", [])
+            environment = entry.get("environment", {})
+            executable = entry.get("executable", "{engine}")
+            if not isinstance(name, str) or not NAME_RE.fullmatch(name):
+                raise SoakError(f"invalid backend name {name!r}")
+            if not isinstance(flags, list) or not all(
+                isinstance(flag, str) for flag in flags
+            ):
+                raise SoakError(f"backend {name!r} flags must be a string list")
+            if not isinstance(environment, dict) or not all(
+                isinstance(key, str) and isinstance(value, str)
+                for key, value in environment.items()
+            ):
+                raise SoakError(f"backend {name!r} environment must map strings")
+            if not isinstance(executable, str):
+                raise SoakError(f"backend {name!r} executable must be a string")
+            sensitive = [key for key in environment if SENSITIVE_ENV_RE.search(key)]
+            if sensitive:
+                raise SoakError(
+                    f"backend {name!r} environment contains secret-like keys {sensitive}"
+                )
+            backends.append(
+                Backend(
+                    name=name,
+                    executable=Path(expand(executable, variables)),
+                    flags=tuple(expand(flag, variables) for flag in flags),
+                    environment={
+                        key: expand(value, variables)
+                        for key, value in environment.items()
+                    },
+                )
+            )
+    else:
+        library_dir = str((args.library_dir or args.engine.parent).resolve())
+        loader_environment: dict[str, str] = {}
+        if platform.system() == "Darwin":
+            loader_environment["DYLD_LIBRARY_PATH"] = library_dir
+        elif platform.system() == "Linux":
+            loader_environment["LD_LIBRARY_PATH"] = library_dir
+        definitions = {
+            "cpu": Backend("cpu", args.engine, (), dict(loader_environment)),
+            "metal": Backend(
+                "metal",
+                args.engine,
+                ("--metal",),
+                dict(loader_environment),
+            ),
+            "metal-v3": Backend(
+                "metal-v3",
+                args.engine,
+                ("--metal-v3",),
+                dict(loader_environment),
+            ),
+        }
+        selected = args.backend or ["cpu"]
+        unknown = [name for name in selected if name not in definitions]
+        if unknown:
+            raise SoakError(
+                f"unknown built-in backend(s) {unknown}; use --backend-config for custom engines"
+            )
+        backends = [definitions[name] for name in selected]
+
+    names = [backend.name for backend in backends]
+    if len(set(names)) != len(names):
+        raise SoakError("backend names must be unique")
+    if len(backends) < 2 and args.reference_report is None:
+        raise SoakError(
+            "a conformance soak requires at least two local backends or --reference-report"
+        )
+    for backend in backends:
+        if not backend.executable.is_file():
+            raise SoakError(f"backend executable is missing: {backend.executable}")
+    return backends
+
+
+def command_for(
+    backend: Backend,
+    args: argparse.Namespace,
+    *,
+    serve: bool,
+    prompt: Prompt | None = None,
+) -> list[str]:
+    command = [
+        str(backend.executable),
+        str(args.model),
+        str(args.tables),
+        "--threads",
+        str(args.threads),
+    ]
+    if serve:
+        command.extend(("--serve", "--max-new", str(args.max_new)))
+    else:
+        if prompt is None:
+            raise AssertionError("one-shot command requires a prompt")
+        command.extend(
+            (
+                "--ids",
+                ",".join(str(value) for value in prompt.ids),
+                "--ndecode",
+                str(args.max_new),
+            )
+        )
+    command.extend(backend.flags)
+    return command
+
+
+class ServeProcess:
+    def __init__(
+        self,
+        backend: Backend,
+        command: list[str],
+        startup_timeout: float,
+    ) -> None:
+        self.backend = backend
+        self.stderr_tail: deque[str] = deque(maxlen=120)
+        self.stdout_queue: queue.Queue[str | None] = queue.Queue()
+        self.process = subprocess.Popen(
+            command,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            bufsize=1,
+            env=clean_environment(backend.environment),
+            start_new_session=(os.name == "posix"),
+        )
+        assert self.process.stdout is not None
+        assert self.process.stderr is not None
+        threading.Thread(
+            target=self._pump_stdout, args=(self.process.stdout,), daemon=True
+        ).start()
+        threading.Thread(
+            target=self._pump_stderr, args=(self.process.stderr,), daemon=True
+        ).start()
+        try:
+            deadline = time.monotonic() + startup_timeout
+            while True:
+                line = self._read(max(0.001, deadline - time.monotonic()))
+                if line == "SERVE_READY":
+                    break
+                if line.startswith("ERR "):
+                    raise SoakError(f"backend {backend.name} startup error: {line}")
+                if time.monotonic() >= deadline:
+                    raise SoakError(f"backend {backend.name} startup timed out")
+        except BaseException:
+            self.terminate()
+            raise
+
+    def _pump_stdout(self, stream: Iterable[str]) -> None:
+        try:
+            for line in stream:
+                self.stdout_queue.put(line.rstrip("\n"))
+        finally:
+            self.stdout_queue.put(None)
+
+    def _pump_stderr(self, stream: Iterable[str]) -> None:
+        for line in stream:
+            self.stderr_tail.append(line.rstrip("\n"))
+
+    def _read(self, timeout: float) -> str:
+        try:
+            line = self.stdout_queue.get(timeout=timeout)
+        except queue.Empty as error:
+            raise SoakError(f"backend {self.backend.name} protocol timed out") from error
+        if line is None:
+            code = self.process.poll()
+            raise SoakError(
+                f"backend {self.backend.name} closed stdout (exit={code}); "
+                f"stderr tail={list(self.stderr_tail)[-8:]}"
+            )
+        return line
+
+    def request(self, prompt: Prompt, timeout: float) -> tuple[list[int], float, int]:
+        if self.process.stdin is None:
+            raise SoakError(f"backend {self.backend.name} has no stdin")
+        try:
+            self.process.stdin.write(",".join(str(value) for value in prompt.ids) + "\n")
+            self.process.stdin.flush()
+        except (BrokenPipeError, OSError) as error:
+            raise SoakError(f"backend {self.backend.name} rejected a request") from error
+
+        deadline = time.monotonic() + timeout
+        generated: list[int] | None = None
+        while True:
+            line = self._read(max(0.001, deadline - time.monotonic()))
+            if line.startswith("GEN "):
+                if generated is not None:
+                    raise SoakError(f"backend {self.backend.name} emitted duplicate GEN")
+                try:
+                    generated = [int(value) for value in line[4:].split(",") if value]
+                except ValueError as error:
+                    raise SoakError(
+                        f"backend {self.backend.name} emitted malformed GEN"
+                    ) from error
+            elif line.startswith("RCPT "):
+                raise SoakError(
+                    f"backend {self.backend.name} unexpectedly emitted a receipt; "
+                    "soak runs must not use audit keys"
+                )
+            elif line.startswith("ERR "):
+                raise SoakError(f"backend {self.backend.name}: {line}")
+            elif match := DONE_RE.fullmatch(line):
+                if generated is None:
+                    raise SoakError(f"backend {self.backend.name} emitted DONE before GEN")
+                seconds = float(match.group(1))
+                token_count = int(match.group(2))
+                if token_count != len(generated):
+                    raise SoakError(
+                        f"backend {self.backend.name} DONE count does not match GEN"
+                    )
+                return generated, seconds, token_count
+            else:
+                raise SoakError(
+                    f"backend {self.backend.name} emitted unknown protocol line {line!r}"
+                )
+            if time.monotonic() >= deadline:
+                raise SoakError(f"backend {self.backend.name} request timed out")
+
+    def close(self) -> None:
+        if self.process.poll() is None and self.process.stdin is not None:
+            try:
+                self.process.stdin.write("/quit\n")
+                self.process.stdin.flush()
+                self.process.stdin.close()
+                self.process.wait(timeout=10)
+            except (BrokenPipeError, OSError, subprocess.TimeoutExpired):
+                self.terminate()
+
+    def terminate(self) -> None:
+        if self.process.poll() is not None:
+            return
+        try:
+            if os.name == "posix":
+                os.killpg(self.process.pid, signal.SIGTERM)
+            else:
+                self.process.terminate()
+            self.process.wait(timeout=5)
+        except (ProcessLookupError, subprocess.TimeoutExpired):
+            if self.process.poll() is None:
+                self.process.kill()
+                self.process.wait(timeout=5)
+
+
+def parse_one_shot(stdout: str, backend_name: str) -> dict[str, Any]:
+    generated_match = re.search(r"^generated = (\[[0-9, ]*\])$", stdout, re.MULTILINE)
+    fnv_match = re.search(r"^ids FNV   = ([0-9a-f]{16})$", stdout, re.MULTILINE)
+    if generated_match is None or fnv_match is None:
+        raise SoakError(f"backend {backend_name} one-shot output is incomplete")
+    generated = ast.literal_eval(generated_match.group(1))
+    if not isinstance(generated, list) or not all(
+        isinstance(value, int) for value in generated
+    ):
+        raise SoakError(f"backend {backend_name} one-shot GEN is malformed")
+    roots: dict[str, str] = {}
+    for name, pattern in ROOT_PATTERNS.items():
+        match = pattern.search(stdout)
+        if match is None:
+            raise SoakError(f"backend {backend_name} omitted {name}")
+        roots[name] = match.group(1)
+    return {"generated": generated, "ids_fnv64": fnv_match.group(1), **roots}
+
+
+def run_one_shot(
+    backend: Backend,
+    prompt: Prompt,
+    args: argparse.Namespace,
+) -> dict[str, Any]:
+    try:
+        completed = subprocess.run(
+            command_for(backend, args, serve=False, prompt=prompt),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            env=clean_environment(backend.environment),
+            timeout=args.one_shot_timeout,
+            check=False,
+            start_new_session=(os.name == "posix"),
+        )
+    except subprocess.TimeoutExpired as error:
+        raise SoakError(f"backend {backend.name} one-shot timed out") from error
+    if completed.returncode != 0:
+        tail = completed.stderr.splitlines()[-8:]
+        raise SoakError(
+            f"backend {backend.name} one-shot exited {completed.returncode}: {tail}"
+        )
+    return parse_one_shot(completed.stdout, backend.name)
+
+
+def percentile_95(values: list[float]) -> float:
+    if not values:
+        return 0.0
+    ordered = sorted(values)
+    index = max(0, (95 * len(ordered) + 99) // 100 - 1)
+    return ordered[index]
+
+
+def recorded_environment(environment: dict[str, str]) -> dict[str, str]:
+    return {
+        key: "<configured-loader-path>"
+        if key in {"DYLD_LIBRARY_PATH", "LD_LIBRARY_PATH"}
+        else value
+        for key, value in sorted(environment.items())
+    }
+
+
+def evaluate(
+    backend_results: dict[str, list[dict[str, Any]]],
+    root_checks: dict[str, dict[str, Any]],
+    prompt_names: list[str],
+) -> list[dict[str, Any]]:
+    mismatches: list[dict[str, Any]] = []
+    backend_names = list(backend_results)
+    reference_name = backend_names[0]
+
+    for backend_name, results in backend_results.items():
+        for prompt_name in prompt_names:
+            prompt_results = [
+                result for result in results if result["prompt"] == prompt_name
+            ]
+            expected = prompt_results[0]["generated"]
+            for result in prompt_results[1:]:
+                if result["generated"] != expected:
+                    mismatches.append(
+                        {
+                            "kind": "backend_reset_drift",
+                            "backend": backend_name,
+                            "prompt": prompt_name,
+                            "iteration": result["iteration"],
+                            "expected": expected,
+                            "actual": result["generated"],
+                        }
+                    )
+
+    reference = {
+        (result["iteration"], result["prompt"]): result["generated"]
+        for result in backend_results[reference_name]
+    }
+    for backend_name in backend_names[1:]:
+        for result in backend_results[backend_name]:
+            key = (result["iteration"], result["prompt"])
+            if result["generated"] != reference[key]:
+                mismatches.append(
+                    {
+                        "kind": "cross_backend_tokens",
+                        "reference_backend": reference_name,
+                        "backend": backend_name,
+                        "prompt": result["prompt"],
+                        "iteration": result["iteration"],
+                        "expected": reference[key],
+                        "actual": result["generated"],
+                    }
+                )
+
+    reference_root = root_checks[reference_name]
+    for backend_name in backend_names[1:]:
+        actual = root_checks[backend_name]
+        for field in ("generated", "ids_fnv64", *ROOT_PATTERNS):
+            if actual[field] != reference_root[field]:
+                mismatches.append(
+                    {
+                        "kind": "cross_backend_execution_root",
+                        "field": field,
+                        "reference_backend": reference_name,
+                        "backend": backend_name,
+                        "expected": reference_root[field],
+                        "actual": actual[field],
+                    }
+                )
+    return mismatches
+
+
+def evaluate_reference(
+    reference: dict[str, Any],
+    artifacts: dict[str, dict[str, Any]],
+    configuration: dict[str, Any],
+    host: dict[str, Any],
+    backend_results: dict[str, list[dict[str, Any]]],
+    root_checks: dict[str, dict[str, Any]],
+) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    mismatches: list[dict[str, Any]] = []
+    if reference.get("schema") == LEGACY_UNATTESTED_SCHEMA:
+        raise SoakError(
+            "reference report uses legacy v1 without the required reproducibility "
+            "manifest; recapture it with the v2 runner"
+        )
+    if reference.get("schema") != SCHEMA:
+        raise SoakError(f"reference report must use schema {SCHEMA!r}")
+    if reference.get("passed") is not True:
+        mismatches.append({"kind": "reference_report_not_passed"})
+
+    reference_configuration = reference.get("configuration", {})
+    for field in ("threads", "max_new", "iterations", "prompts"):
+        local_value = configuration[field]
+        reference_value = reference_configuration.get(field)
+        if local_value != reference_value:
+            mismatches.append(
+                {
+                    "kind": "reference_configuration",
+                    "field": field,
+                    "expected": reference_value,
+                    "actual": local_value,
+                }
+            )
+
+    reference_artifacts = reference.get("artifacts", {})
+    for name in ("model", "tables", "source"):
+        local_artifact = artifacts.get(name)
+        reference_artifact = reference_artifacts.get(name)
+        if local_artifact is None and reference_artifact is None:
+            continue
+        if local_artifact is None or reference_artifact is None:
+            mismatches.append(
+                {"kind": "reference_artifact_missing", "artifact": name}
+            )
+        elif local_artifact.get("sha256") != reference_artifact.get("sha256"):
+            mismatches.append(
+                {
+                    "kind": "reference_artifact_hash",
+                    "artifact": name,
+                    "expected": reference_artifact.get("sha256"),
+                    "actual": local_artifact.get("sha256"),
+                }
+            )
+
+    reference_host = reference.get("host", {})
+    host_identity = (host.get("system"), host.get("machine"))
+    reference_identity = (
+        reference_host.get("system"),
+        reference_host.get("machine"),
+    )
+    if host_identity == reference_identity:
+        mismatches.append(
+            {
+                "kind": "reference_host_not_independent",
+                "host_identity": list(host_identity),
+            }
+        )
+
+    reference_measurements = reference.get("measurements")
+    reference_roots = reference.get("root_checks")
+    reference_backends = reference.get("backends")
+    if (
+        not isinstance(reference_measurements, dict)
+        or not isinstance(reference_roots, dict)
+        or not isinstance(reference_backends, list)
+        or not reference_backends
+    ):
+        raise SoakError("reference report is missing backend evidence")
+    reference_backend = reference_backends[0].get("name")
+    if (
+        not isinstance(reference_backend, str)
+        or reference_backend not in reference_measurements
+        or reference_backend not in reference_roots
+    ):
+        raise SoakError("reference report's first backend is inconsistent")
+    expected_rows = reference_measurements[reference_backend]
+    expected_by_key = {
+        (row["iteration"], row["prompt"]): row["generated"]
+        for row in expected_rows
+    }
+    for backend_name, rows in backend_results.items():
+        actual_by_key = {
+            (row["iteration"], row["prompt"]): row["generated"] for row in rows
+        }
+        if actual_by_key.keys() != expected_by_key.keys():
+            mismatches.append(
+                {
+                    "kind": "reference_schedule",
+                    "reference_backend": reference_backend,
+                    "backend": backend_name,
+                }
+            )
+            continue
+        for key, expected in expected_by_key.items():
+            actual = actual_by_key[key]
+            if actual != expected:
+                mismatches.append(
+                    {
+                        "kind": "cross_host_tokens",
+                        "reference_backend": reference_backend,
+                        "backend": backend_name,
+                        "iteration": key[0],
+                        "prompt": key[1],
+                        "expected": expected,
+                        "actual": actual,
+                    }
+                )
+
+    expected_root = reference_roots[reference_backend]
+    for backend_name, actual_root in root_checks.items():
+        for field in ("generated", "ids_fnv64", *ROOT_PATTERNS):
+            if actual_root[field] != expected_root[field]:
+                mismatches.append(
+                    {
+                        "kind": "cross_host_execution_root",
+                        "field": field,
+                        "reference_backend": reference_backend,
+                        "backend": backend_name,
+                        "expected": expected_root[field],
+                        "actual": actual_root[field],
+                    }
+                )
+
+    record = {
+        "report_sha256": reference["_report_sha256"],
+        "backend": reference_backend,
+        "host": reference_host,
+        "passed": reference.get("passed"),
+    }
+    return mismatches, record
+
+
+def host_record() -> dict[str, Any]:
+    record: dict[str, Any] = {
+        "system": platform.system(),
+        "release": platform.release(),
+        "machine": platform.machine(),
+        "python": platform.python_version(),
+    }
+    if platform.system() == "Darwin":
+        for key in ("machdep.cpu.brand_string", "hw.model", "hw.memsize"):
+            completed = subprocess.run(
+                ["/usr/sbin/sysctl", "-n", key],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if completed.returncode == 0:
+                record[key] = completed.stdout.strip()
+    if shutil.which("nvidia-smi") is not None:
+        completed = subprocess.run(
+            [
+                "nvidia-smi",
+                "--query-gpu=name,compute_cap,driver_version",
+                "--format=csv,noheader",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if completed.returncode == 0:
+            record["nvidia_gpus"] = completed.stdout.strip().splitlines()
+    return record
+
+
+def write_new_json(path: Path, value: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(
+        dir=path.parent, prefix=f".{path.name}.", suffix=".tmp"
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as output:
+            json.dump(value, output, indent=2, sort_keys=True)
+            output.write("\n")
+            output.flush()
+            os.fsync(output.fileno())
+        os.link(temporary, path)
+    except FileExistsError as error:
+        raise SoakError(f"refusing to overwrite existing report {path}") from error
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def canonical_record_sha256(value: Any) -> str:
+    encoded = json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def reproducibility_manifest(
+    args: argparse.Namespace,
+    backends: list[Backend],
+) -> dict[str, Any]:
+    """Build a path-free manifest binding the runner, plan, and declared DSOs."""
+    normalized_backends = [
+        {
+            "name": backend.name,
+            "executable": artifact_record(backend.executable),
+            "flags": list(backend.flags),
+            "environment": recorded_environment(backend.environment),
+        }
+        for backend in backends
+    ]
+    backend_config = getattr(args, "backend_config", None)
+    if backend_config is None:
+        plan = {
+            "kind": "built-in",
+            "selected_backends": [backend.name for backend in backends],
+        }
+    else:
+        plan = {
+            "kind": "external-file",
+            "artifact": artifact_record(backend_config),
+        }
+    runtime_libraries = [
+        artifact_record(path)
+        for path in (getattr(args, "runtime_library", None) or [])
+    ]
+    return {
+        "schema": "misaka.qi35.soak-reproducibility.v1",
+        "runner": artifact_record(Path(__file__).resolve()),
+        "backend_plan": {
+            **plan,
+            "canonical_sha256": canonical_record_sha256(normalized_backends),
+            "normalized_backends": normalized_backends,
+        },
+        "non_system_runtime_libraries": {
+            "declaration": (
+                "explicit-files"
+                if runtime_libraries
+                else "explicit-none-system-or-static-only"
+            ),
+            "count": len(runtime_libraries),
+            "artifacts": runtime_libraries,
+        },
+    }
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--engine", required=True, type=Path)
+    parser.add_argument("--model", required=True, type=Path)
+    parser.add_argument("--tables", required=True, type=Path)
+    parser.add_argument("--source", type=Path)
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument(
+        "--backend",
+        action="append",
+        help="built-in backend (cpu, metal, metal-v3); repeat for each backend",
+    )
+    parser.add_argument("--backend-config", type=Path)
+    parser.add_argument("--reference-report", type=Path)
+    parser.add_argument("--library-dir", type=Path)
+    runtime_group = parser.add_mutually_exclusive_group(required=True)
+    runtime_group.add_argument(
+        "--runtime-library",
+        action="append",
+        type=Path,
+        help="Non-system runtime DSO; repeat for every declared library",
+    )
+    runtime_group.add_argument(
+        "--no-non-system-runtime-libraries",
+        action="store_true",
+        help="Explicitly attest that the engine is static or uses system libraries only",
+    )
+    parser.add_argument("--prompt", action="append", default=[])
+    parser.add_argument("--iterations", type=int, default=20)
+    parser.add_argument("--warmup", type=int, default=2)
+    parser.add_argument("--max-new", type=int, default=8)
+    parser.add_argument("--threads", type=int, default=8)
+    parser.add_argument("--vocab-size", type=int, default=248_320)
+    parser.add_argument("--startup-timeout", type=float, default=300.0)
+    parser.add_argument("--request-timeout", type=float, default=180.0)
+    parser.add_argument("--one-shot-timeout", type=float, default=600.0)
+    return parser
+
+
+def validate_args(args: argparse.Namespace) -> None:
+    for label in ("engine", "model", "tables"):
+        path = getattr(args, label)
+        if not path.is_file():
+            raise SoakError(f"{label} does not exist: {path}")
+    if args.source is not None and not args.source.is_file():
+        raise SoakError(f"source does not exist: {args.source}")
+    if args.reference_report is not None and not args.reference_report.is_file():
+        raise SoakError(f"reference report does not exist: {args.reference_report}")
+    runtime_libraries = getattr(args, "runtime_library", None) or []
+    for path in runtime_libraries:
+        if not path.is_file():
+            raise SoakError(f"runtime library does not exist: {path}")
+    if len({path.resolve() for path in runtime_libraries}) != len(runtime_libraries):
+        raise SoakError("--runtime-library entries must be unique")
+    for label in ("iterations", "max_new", "threads", "vocab_size"):
+        if getattr(args, label) <= 0:
+            raise SoakError(f"--{label.replace('_', '-')} must be positive")
+    if args.warmup < 0:
+        raise SoakError("--warmup must be non-negative")
+    for label in ("startup_timeout", "request_timeout", "one_shot_timeout"):
+        if getattr(args, label) <= 0:
+            raise SoakError(f"--{label.replace('_', '-')} must be positive")
+
+
+def run(args: argparse.Namespace) -> dict[str, Any]:
+    validate_args(args)
+    prompt_specs = args.prompt or list(DEFAULT_PROMPTS)
+    prompts = [parse_prompt_spec(spec, args.vocab_size) for spec in prompt_specs]
+    prompt_names = [prompt.name for prompt in prompts]
+    if len(set(prompt_names)) != len(prompt_names):
+        raise SoakError("prompt names must be unique")
+    backends = load_backends(args)
+    manifest = reproducibility_manifest(args, backends)
+
+    started_at = utc_now()
+    artifacts = {
+        "runner": manifest["runner"],
+        "engine": artifact_record(args.engine),
+        "model": artifact_record(args.model),
+        "tables": artifact_record(args.tables),
+        "runtime_libraries": manifest["non_system_runtime_libraries"]["artifacts"],
+    }
+    if args.source is not None:
+        artifacts["source"] = artifact_record(args.source)
+    if args.backend_config is not None:
+        artifacts["backend_plan"] = manifest["backend_plan"]["artifact"]
+    host = host_record()
+    configuration = {
+        "threads": args.threads,
+        "max_new": args.max_new,
+        "warmup": args.warmup,
+        "iterations": args.iterations,
+        "prompts": [
+            {"name": prompt.name, "ids": list(prompt.ids)} for prompt in prompts
+        ],
+        "inherited_qi35_environment": "scrubbed",
+        "non_system_runtime_library_count": manifest[
+            "non_system_runtime_libraries"
+        ]["count"],
+    }
+    results: dict[str, list[dict[str, Any]]] = {}
+    root_checks: dict[str, dict[str, Any]] = {}
+    backend_records: list[dict[str, Any]] = []
+
+    for backend in backends:
+        process: ServeProcess | None = None
+        backend_results: list[dict[str, Any]] = []
+        try:
+            process = ServeProcess(
+                backend,
+                command_for(backend, args, serve=True),
+                args.startup_timeout,
+            )
+            for _ in range(args.warmup):
+                for prompt in prompts:
+                    process.request(prompt, args.request_timeout)
+            for iteration in range(args.iterations):
+                for prompt in prompts:
+                    generated, seconds, token_count = process.request(
+                        prompt, args.request_timeout
+                    )
+                    backend_results.append(
+                        {
+                            "iteration": iteration,
+                            "prompt": prompt.name,
+                            "generated": generated,
+                            "seconds": seconds,
+                            "tokens": token_count,
+                        }
+                    )
+        finally:
+            if process is not None:
+                process.close()
+        assert process is not None
+        results[backend.name] = backend_results
+        seconds = [result["seconds"] for result in backend_results]
+        token_total = sum(result["tokens"] for result in backend_results)
+        second_total = sum(seconds)
+        backend_records.append(
+            {
+                "name": backend.name,
+                "executable_sha256": artifact_record(backend.executable)["sha256"],
+                "flags": list(backend.flags),
+                "explicit_environment": recorded_environment(backend.environment),
+                "stderr_tail": list(process.stderr_tail),
+                "measurements": len(backend_results),
+                "tokens": token_total,
+                "seconds": round(second_total, 6),
+                "tokens_per_second": round(token_total / second_total, 6)
+                if second_total
+                else None,
+                "latency_seconds": {
+                    "min": min(seconds),
+                    "median": statistics.median(seconds),
+                    "p95": percentile_95(seconds),
+                    "max": max(seconds),
+                },
+            }
+        )
+        root_checks[backend.name] = run_one_shot(backend, prompts[0], args)
+
+    mismatches = evaluate(results, root_checks, prompt_names)
+    reference_record: dict[str, Any] | None = None
+    if args.reference_report is not None:
+        reference_bytes = args.reference_report.read_bytes()
+        reference = json.loads(reference_bytes)
+        reference["_report_sha256"] = hashlib.sha256(reference_bytes).hexdigest()
+        reference_mismatches, reference_record = evaluate_reference(
+            reference,
+            artifacts,
+            configuration,
+            host,
+            results,
+            root_checks,
+        )
+        mismatches.extend(reference_mismatches)
+    report = {
+        "schema": SCHEMA,
+        "started_at_utc": started_at,
+        "finished_at_utc": utc_now(),
+        "passed": not mismatches,
+        "criteria": {
+            "minimum_local_backends_without_reference": 2,
+            "local_backend_count": len(backends),
+            "independent_host_reference": args.reference_report is not None,
+            "reset_determinism": "every prompt output is invariant across iterations",
+            "cross_backend_tokens": "every scheduled generated token sequence is identical",
+            "cross_backend_execution_roots": (
+                "generated ids, FNV64, route root, KV root, and state root are identical"
+            ),
+            "artifact_provenance": (
+                "runner, backend plan, and every declared non-system runtime library "
+                "are content-addressed"
+            ),
+        },
+        "host": host,
+        "artifacts": artifacts,
+        "configuration": configuration,
+        "backends": backend_records,
+        "root_check_prompt": prompts[0].name,
+        "root_checks": root_checks,
+        "measurements": results,
+        "mismatches": mismatches,
+        "reproducibility": manifest,
+    }
+    if reference_record is not None:
+        report["reference"] = reference_record
+    return report
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+    try:
+        report = run(args)
+        write_new_json(args.output, report)
+    except (OSError, ValueError, json.JSONDecodeError, SoakError) as error:
+        print(f"qi35-soak: ERROR: {error}", file=sys.stderr)
+        return 2
+    status = "PASS" if report["passed"] else "FAIL"
+    total = sum(backend["tokens"] for backend in report["backends"])
+    print(
+        f"qi35-soak: {status}; backends={len(report['backends'])} "
+        f"tokens={total} mismatches={len(report['mismatches'])}"
+    )
+    print(f"report: {args.output}")
+    return 0 if report["passed"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/tests/test_qi35_calibrate.py b/scripts/tests/test_qi35_calibrate.py
new file mode 100644
index 0000000000000000000000000000000000000000..7bb6f1c87b58ddf0d0e4688a6201a35bdc19aa92
--- /dev/null
+++ b/scripts/tests/test_qi35_calibrate.py
@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+from scripts.qi35_calibrate import (
+    LEGACY_UNATTESTED_SCHEMA,
+    LlamaServer,
+    SCHEMA,
+    common_prefix_length,
+    direct_http_opener,
+    quality_summary,
+    runtime_drift,
+    validate_runtime_libraries,
+)
+from scripts.qi35_soak import Prompt, SoakError
+
+
+class Qi35CalibrationTests(unittest.TestCase):
+    def test_v2_schema_separates_legacy_unattested_calibration(self) -> None:
+        self.assertEqual(SCHEMA, "misaka.qi35.fp-calibration.v2")
+        self.assertEqual(LEGACY_UNATTESTED_SCHEMA, "misaka.qi35.fp-calibration.v1")
+
+    def test_engine_library_manifest_is_required_existing_and_unique(self) -> None:
+        with self.assertRaisesRegex(SoakError, "at least one"):
+            validate_runtime_libraries([], "--engine-library")
+        with tempfile.TemporaryDirectory() as directory:
+            library = Path(directory) / "libqi35metal.dylib"
+            with self.assertRaisesRegex(SoakError, "not a file"):
+                validate_runtime_libraries([library], "--engine-library")
+            library.write_bytes(b"metal")
+            validate_runtime_libraries([library], "--engine-library")
+            with self.assertRaisesRegex(SoakError, "unique"):
+                validate_runtime_libraries(
+                    [library, library],
+                    "--engine-library",
+                )
+
+    def test_common_prefix_stops_at_first_divergence(self) -> None:
+        self.assertEqual(common_prefix_length([1, 2, 3], [1, 9, 3]), 1)
+        self.assertEqual(common_prefix_length([1, 2], [1, 2]), 2)
+
+    def test_quality_does_not_treat_post_divergence_match_as_prefix(self) -> None:
+        integer = [{"prompt": "p", "generated": [1, 2, 3]}]
+        fp = [{"prompt": "p", "generated": [1, 9, 3]}]
+        summary = quality_summary(integer, fp, ["p"])
+        self.assertEqual(summary["prefix_match_tokens"], 1)
+        self.assertEqual(summary["exact_position_matches"], 2)
+        self.assertEqual(summary["per_prompt"][0]["first_divergence_index"], 1)
+
+    def test_runtime_drift_is_runtime_local(self) -> None:
+        rows = [
+            {"iteration": 0, "prompt": "p", "generated": [1]},
+            {"iteration": 1, "prompt": "p", "generated": [2]},
+        ]
+        failures = runtime_drift(rows, ["p"], "fixture")
+        self.assertEqual(len(failures), 1)
+        self.assertEqual(failures[0]["runtime"], "fixture")
+
+    def test_llama_completion_ignores_inherited_http_proxy(self) -> None:
+        target_requests = []
+        proxy_requests = []
+
+        def handler(tokens, requests):
+            class Handler(BaseHTTPRequestHandler):
+                def do_POST(self):
+                    requests.append(self.path)
+                    length = int(self.headers.get("Content-Length", "0"))
+                    self.rfile.read(length)
+                    body = json.dumps({"tokens": tokens, "timings": {}}).encode("utf-8")
+                    self.send_response(200)
+                    self.send_header("Content-Length", str(len(body)))
+                    self.end_headers()
+                    self.wfile.write(body)
+
+                def log_message(self, *_args):
+                    pass
+
+            return Handler
+
+        target = HTTPServer(("127.0.0.1", 0), handler([7, 8], target_requests))
+        proxy = HTTPServer(("127.0.0.1", 0), handler([9, 9], proxy_requests))
+        target_thread = threading.Thread(target=target.serve_forever, daemon=True)
+        proxy_thread = threading.Thread(target=proxy.serve_forever, daemon=True)
+        target_thread.start()
+        proxy_thread.start()
+        self.addCleanup(target.server_close)
+        self.addCleanup(target_thread.join)
+        self.addCleanup(target.shutdown)
+        self.addCleanup(proxy.server_close)
+        self.addCleanup(proxy_thread.join)
+        self.addCleanup(proxy.shutdown)
+
+        instance = object.__new__(LlamaServer)
+        instance.url = f"http://127.0.0.1:{target.server_port}"
+        instance.opener = direct_http_opener()
+        proxy_url = f"http://127.0.0.1:{proxy.server_port}"
+        environment = {
+            "HTTP_PROXY": proxy_url,
+            "NO_PROXY": "",
+            "http_proxy": proxy_url,
+            "no_proxy": "",
+        }
+        with mock.patch.dict(os.environ, environment):
+            result = instance.complete(
+                Prompt("p", (1,)),
+                SimpleNamespace(max_new=2, request_timeout=2.0),
+            )
+        self.assertEqual(result["generated"], [7, 8])
+        self.assertEqual(len(target_requests), 1)
+        self.assertEqual(proxy_requests, [])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/tests/test_qi35_fp_probe.py b/scripts/tests/test_qi35_fp_probe.py
new file mode 100644
index 0000000000000000000000000000000000000000..47c1f8d2bb59d3e3cefa673886e07a5263dec92f
--- /dev/null
+++ b/scripts/tests/test_qi35_fp_probe.py
@@ -0,0 +1,397 @@
+import argparse
+import contextlib
+import io
+import json
+import os
+import re
+import tempfile
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+from scripts.qi35_calibrate import (
+    LEGACY_UNATTESTED_SCHEMA as LEGACY_REFERENCE_SCHEMA,
+    SCHEMA as REFERENCE_SCHEMA,
+)
+from scripts.qi35_fp_probe import (
+    LEGACY_UNATTESTED_SCHEMA,
+    MATCHED_ARTIFACTS,
+    SCHEMA,
+    bind_declared_libraries,
+    complete,
+    cuda_log_attestation,
+    gpu_record,
+    local_server_url,
+    parse_args,
+    read_reference,
+    server_command,
+    verify_artifact_identity,
+)
+from scripts.qi35_soak import Prompt, SoakError
+
+
+class LocalServerUrlTests(unittest.TestCase):
+    def test_accepts_explicit_loopback_origins(self):
+        self.assertEqual(local_server_url("http://127.0.0.1:18081/"), "http://127.0.0.1:18081")
+        self.assertEqual(local_server_url("http://[::1]:9000"), "http://[::1]:9000")
+
+    def test_rejects_remote_auth_and_paths(self):
+        invalid = (
+            "https://127.0.0.1:8080",
+            "http://192.0.2.1:8080",
+            "http://localhost:8080",
+            "http://user@127.0.0.1:8080",
+            "http://127.0.0.1:8080/completion",
+            "http://127.0.0.1",
+        )
+        for raw in invalid:
+            with self.subTest(raw=raw), self.assertRaises(argparse.ArgumentTypeError):
+                local_server_url(raw)
+
+
+class DirectTransportTests(unittest.TestCase):
+    def start_server(self, tokens):
+        requests = []
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_POST(self):
+                requests.append(self.path)
+                length = int(self.headers.get("Content-Length", "0"))
+                self.rfile.read(length)
+                body = json.dumps({"tokens": tokens, "timings": {}}).encode("utf-8")
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+
+            def log_message(self, *_args):
+                pass
+
+        server = HTTPServer(("127.0.0.1", 0), Handler)
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        self.addCleanup(server.server_close)
+        self.addCleanup(thread.join)
+        self.addCleanup(server.shutdown)
+        return server, requests
+
+    def start_redirect_server(self, location):
+        requests = []
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_POST(self):
+                requests.append(self.path)
+                length = int(self.headers.get("Content-Length", "0"))
+                self.rfile.read(length)
+                self.send_response(302)
+                self.send_header("Location", location)
+                self.end_headers()
+
+            def log_message(self, *_args):
+                pass
+
+        server = HTTPServer(("127.0.0.1", 0), Handler)
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        self.addCleanup(server.server_close)
+        self.addCleanup(thread.join)
+        self.addCleanup(server.shutdown)
+        return server, requests
+
+    def test_completion_ignores_inherited_http_proxy(self):
+        target, target_requests = self.start_server([7, 8])
+        proxy, proxy_requests = self.start_server([9, 9])
+        proxy_url = f"http://127.0.0.1:{proxy.server_port}"
+        environment = {
+            "ALL_PROXY": proxy_url,
+            "HTTP_PROXY": proxy_url,
+            "HTTPS_PROXY": proxy_url,
+            "NO_PROXY": "",
+            "all_proxy": proxy_url,
+            "http_proxy": proxy_url,
+            "https_proxy": proxy_url,
+            "no_proxy": "",
+        }
+        with mock.patch.dict(os.environ, environment):
+            result = complete(
+                f"http://127.0.0.1:{target.server_port}",
+                Prompt("p", (1,)),
+                2,
+                2.0,
+            )
+        self.assertEqual(result["generated"], [7, 8])
+        self.assertEqual(len(target_requests), 1)
+        self.assertEqual(proxy_requests, [])
+
+    def test_completion_rejects_redirects(self):
+        redirected, redirected_requests = self.start_server([7, 8])
+        redirect_url = f"http://127.0.0.1:{redirected.server_port}/completion"
+        source, source_requests = self.start_redirect_server(redirect_url)
+        with self.assertRaisesRegex(SoakError, "request failed"):
+            complete(
+                f"http://127.0.0.1:{source.server_port}",
+                Prompt("p", (1,)),
+                2,
+                2.0,
+            )
+        self.assertEqual(len(source_requests), 1)
+        self.assertEqual(redirected_requests, [])
+
+
+class AttestationTests(unittest.TestCase):
+    def test_probe_schema_separates_legacy_unattested_reports(self):
+        self.assertEqual(SCHEMA, "misaka.qi35.fp-cross-host-probe.v2")
+        self.assertEqual(
+            LEGACY_UNATTESTED_SCHEMA,
+            "misaka.qi35.fp-cross-host-probe.v1",
+        )
+
+    def test_server_command_pins_loopback_cuda_and_trace_logging(self):
+        args = SimpleNamespace(
+            server_binary=Path("/runner/llama-server"),
+            model=Path("/models/qi35.gguf"),
+            context_size=1024,
+        )
+        command = server_command(args, 18081)
+        self.assertEqual(command[0], "/runner/llama-server")
+        self.assertEqual(command[command.index("-m") + 1], "/models/qi35.gguf")
+        self.assertEqual(command[command.index("-ngl") + 1], "all")
+        self.assertEqual(command[command.index("--host") + 1], "127.0.0.1")
+        self.assertEqual(command[command.index("--log-verbosity") + 1], "4")
+
+    def test_library_binding_rejects_runtime_relevant_undeclared_mappings(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            library_dir = root / "llama"
+            system_dir = root / "driver"
+            library_dir.mkdir()
+            system_dir.mkdir()
+            declared = library_dir / "libggml-cuda.so.0"
+            declared.write_bytes(b"declared")
+            fixtures = (
+                library_dir / "libfixture.so.1",
+                system_dir / "libcublasLt.so.13",
+            )
+            for undeclared in fixtures:
+                undeclared.write_bytes(b"undeclared")
+                with self.subTest(undeclared=undeclared.name), mock.patch(
+                    "scripts.qi35_fp_probe.proc_mapped_files",
+                    return_value=[declared, undeclared],
+                ):
+                    with self.assertRaisesRegex(
+                        SoakError,
+                        f"not declared: {re.escape(undeclared.name)}",
+                    ) as raised:
+                        bind_declared_libraries(123, [declared], library_dir)
+                    self.assertNotIn(directory, str(raised.exception))
+
+            complete_set = [declared, *fixtures]
+            with mock.patch(
+                "scripts.qi35_fp_probe.proc_mapped_files",
+                return_value=complete_set,
+            ):
+                bindings = bind_declared_libraries(
+                    123,
+                    complete_set,
+                    library_dir,
+                )
+            self.assertEqual(len(bindings), 3)
+            self.assertTrue(all(item["runtime_relevant"] for item in bindings))
+
+    def test_explicit_nvidia_smi_ignores_path_shim_and_inherited_environment(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            marker = root / "path-shim-ran"
+            shim_dir = root / "shim"
+            shim_dir.mkdir()
+            shim = shim_dir / "nvidia-smi"
+            shim.write_text(
+                f"#!/bin/sh\nprintf used > {marker}\n",
+                encoding="utf-8",
+            )
+            shim.chmod(0o755)
+            explicit = root / "declared-nvidia-smi"
+            explicit.write_text(
+                "#!/bin/sh\n"
+                "if [ \"${HTTP_PROXY+x}\" = x ]; then exit 9; fi\n"
+                "printf 'NVIDIA RTX 4060 Ti, 8.9, 16380, 580.95.05\\n'\n",
+                encoding="utf-8",
+            )
+            explicit.chmod(0o755)
+            with mock.patch.dict(
+                os.environ,
+                {
+                    "PATH": str(shim_dir),
+                    "HTTP_PROXY": "http://127.0.0.1:9",
+                },
+            ):
+                devices = gpu_record(explicit)
+            self.assertEqual(len(devices), 1)
+            self.assertEqual(devices[0]["compute_cap"], "8.9")
+            self.assertFalse(marker.exists())
+
+    def test_parser_requires_existing_executable_nvidia_smi(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            files = {}
+            for name in (
+                "llama-server",
+                "libggml-cuda.so.0",
+                "model.gguf",
+                "tokenizer.json",
+                "corpus.json",
+                "llama.patch",
+                "reference.json",
+            ):
+                files[name] = root / name
+                files[name].write_bytes(b"fixture")
+            files["llama-server"].chmod(0o755)
+            base = [
+                "qi35_fp_probe.py",
+                "--server-binary",
+                str(files["llama-server"]),
+                "--server-library-dir",
+                str(root),
+                "--server-library",
+                str(files["libggml-cuda.so.0"]),
+                "--model",
+                str(files["model.gguf"]),
+                "--tokenizer",
+                str(files["tokenizer.json"]),
+                "--corpus",
+                str(files["corpus.json"]),
+                "--llama-patch",
+                str(files["llama.patch"]),
+                "--llama-revision",
+                "12" * 20,
+                "--reference-calibration",
+                str(files["reference.json"]),
+                "--output",
+                str(root / "output.json"),
+            ]
+            with contextlib.redirect_stderr(io.StringIO()), mock.patch(
+                "sys.argv",
+                base,
+            ), self.assertRaises(SystemExit):
+                parse_args()
+
+            fake = root / "nvidia-smi"
+            fake.write_bytes(b"not executable")
+            with contextlib.redirect_stderr(io.StringIO()), mock.patch(
+                "sys.argv",
+                [*base, "--nvidia-smi", str(fake)],
+            ), self.assertRaises(SystemExit):
+                parse_args()
+
+            fake.chmod(0o755)
+            with mock.patch("sys.argv", [*base, "--nvidia-smi", str(fake)]):
+                parsed = parse_args()
+            self.assertEqual(parsed.nvidia_smi, fake.resolve())
+
+    def test_cuda_log_requires_revision_backend_and_full_offload(self):
+        lines = [
+            "main: build 10015 (12127def) with gcc",
+            "ggml_cuda_init: found 1 CUDA devices (Total VRAM: 8188 MiB):",
+            "load_tensors: offloaded 65/65 layers to GPU",
+        ]
+        result = cuda_log_attestation(
+            lines,
+            "12127defda4f41b7679cb2477a4b0d65ee6a0c8f",
+        )
+        self.assertTrue(result["full_gpu_layer_offload"])
+        self.assertEqual(result["cuda_device_count"], 1)
+        self.assertEqual(result["offloaded_layers"], 65)
+
+        pinned_build_lines = [
+            "main: build 10015 (12127def) with gcc",
+            "0.00.128.223 I cmn  common_param: device_info:",
+            "0.00.567.764 I cmn  common_param:   - CUDA0   : NVIDIA GeForce RTX 4060 Ti (8187 MiB, 7063 MiB free)",
+            "load_tensors: offloaded 41/41 layers to GPU",
+        ]
+        pinned_result = cuda_log_attestation(
+            pinned_build_lines,
+            "12127defda4f41b7679cb2477a4b0d65ee6a0c8f",
+        )
+        self.assertEqual(pinned_result["cuda_device_count"], 1)
+        self.assertEqual(pinned_result["offloaded_layers"], 41)
+
+        with self.assertRaisesRegex(SoakError, "non-contiguous"):
+            cuda_log_attestation(
+                [
+                    pinned_build_lines[0],
+                    "common_param: - CUDA1 : second device only",
+                    pinned_build_lines[3],
+                ],
+                "12127defda4f41b7679cb2477a4b0d65ee6a0c8f",
+            )
+        with self.assertRaisesRegex(SoakError, "counts disagree"):
+            cuda_log_attestation(
+                [
+                    *lines[:2],
+                    "common_params_print_info: device_info: - CUDA0: first device",
+                    "common_params_print_info: device_info: - CUDA1: second device",
+                    lines[2],
+                ],
+                "12127defda4f41b7679cb2477a4b0d65ee6a0c8f",
+            )
+
+        with self.assertRaisesRegex(SoakError, "fully offload"):
+            cuda_log_attestation(
+                [*lines[:-1], "load_tensors: offloaded 64/65 layers to GPU"],
+                "12127defda4f41b7679cb2477a4b0d65ee6a0c8f",
+            )
+        with self.assertRaisesRegex(SoakError, "revision differs"):
+            cuda_log_attestation(lines, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+
+
+class ReferenceTests(unittest.TestCase):
+    def write_report(self, report):
+        directory = tempfile.TemporaryDirectory()
+        path = Path(directory.name) / "reference.json"
+        path.write_text(json.dumps(report), encoding="utf-8")
+        self.addCleanup(directory.cleanup)
+        return path
+
+    def base_report(self):
+        return {
+            "schema": REFERENCE_SCHEMA,
+            "measurement_complete": True,
+            "configuration": {"iterations": 1, "max_new": 2},
+            "integer_measurements": [
+                {"iteration": 0, "prompt": "p", "generated": [7, 8]}
+            ],
+        }
+
+    def test_reference_requires_exact_order_and_coverage(self):
+        report, rows = read_reference(self.write_report(self.base_report()), ["p"], 1, 2)
+        self.assertTrue(report["measurement_complete"])
+        self.assertEqual(rows[0]["generated"], [7, 8])
+
+        malformed = self.base_report()
+        malformed["integer_measurements"][0]["prompt"] = "other"
+        with self.assertRaises(SoakError):
+            read_reference(self.write_report(malformed), ["p"], 1, 2)
+
+        legacy = self.base_report()
+        legacy["schema"] = LEGACY_REFERENCE_SCHEMA
+        with self.assertRaisesRegex(SoakError, "legacy v1"):
+            read_reference(self.write_report(legacy), ["p"], 1, 2)
+
+    def test_artifact_identity_checks_size_and_digest(self):
+        records = {
+            name: {"sha256": f"sha-{name}", "bytes": index + 1}
+            for index, name in enumerate(MATCHED_ARTIFACTS)
+        }
+        verify_artifact_identity({"artifacts": records}, records)
+        changed = {name: dict(record) for name, record in records.items()}
+        changed["model"]["bytes"] += 1
+        with self.assertRaises(SoakError):
+            verify_artifact_identity({"artifacts": records}, changed)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/tests/test_qi35_soak.py b/scripts/tests/test_qi35_soak.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f673467abb96e39a74f3d39385284b1c54113d7
--- /dev/null
+++ b/scripts/tests/test_qi35_soak.py
@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+
+from scripts.qi35_soak import (
+    Backend,
+    LEGACY_UNATTESTED_SCHEMA,
+    SCHEMA,
+    SoakError,
+    build_parser,
+    evaluate,
+    evaluate_reference,
+    parse_one_shot,
+    parse_prompt_spec,
+    reproducibility_manifest,
+)
+
+
+class Qi35SoakTests(unittest.TestCase):
+    def test_v2_schema_separates_legacy_unattested_reports(self) -> None:
+        self.assertEqual(SCHEMA, "misaka.qi35.hardware-soak.v2")
+        self.assertEqual(LEGACY_UNATTESTED_SCHEMA, "misaka.qi35.hardware-soak.v1")
+
+    def test_reproducibility_manifest_binds_runner_plan_and_libraries(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            engine = root / "engine"
+            library = root / "libfixture.so"
+            engine.write_bytes(b"engine")
+            library.write_bytes(b"library")
+            backend = Backend("cpu", engine, ("--safe",), {"LD_LIBRARY_PATH": directory})
+            manifest = reproducibility_manifest(
+                SimpleNamespace(backend_config=None, runtime_library=[library]),
+                [backend],
+            )
+            self.assertEqual(manifest["non_system_runtime_libraries"]["count"], 1)
+            self.assertEqual(
+                manifest["non_system_runtime_libraries"]["artifacts"][0]["basename"],
+                "libfixture.so",
+            )
+            self.assertEqual(len(manifest["backend_plan"]["canonical_sha256"]), 64)
+            self.assertNotIn(directory, json.dumps(manifest))
+            static_manifest = reproducibility_manifest(
+                SimpleNamespace(backend_config=None, runtime_library=None),
+                [backend],
+            )
+            self.assertEqual(
+                static_manifest["non_system_runtime_libraries"]["declaration"],
+                "explicit-none-system-or-static-only",
+            )
+
+    def test_documented_warmup_is_the_cli_default(self) -> None:
+        self.assertEqual(build_parser().get_default("warmup"), 2)
+
+    def test_prompt_is_strict_and_vocab_bounded(self) -> None:
+        prompt = parse_prompt_spec("paris=760,6511,314", 10_000)
+        self.assertEqual(prompt.name, "paris")
+        self.assertEqual(prompt.ids, (760, 6511, 314))
+        with self.assertRaisesRegex(SoakError, "outside"):
+            parse_prompt_spec("bad=10000", 10_000)
+        with self.assertRaisesRegex(SoakError, "invalid prompt"):
+            parse_prompt_spec("No Spaces=1", 10_000)
+
+    def test_one_shot_parser_requires_all_execution_roots(self) -> None:
+        digest = "ab" * 32
+        output = "\n".join(
+            (
+                "generated = [1, 2]",
+                "ids FNV   = 0123456789abcdef",
+                f"route_root = {digest}",
+                f"kv_root = {digest}",
+                f"state_root = {digest}",
+            )
+        )
+        parsed = parse_one_shot(output, "fixture")
+        self.assertEqual(parsed["generated"], [1, 2])
+        self.assertEqual(parsed["state_root"], digest)
+        with self.assertRaisesRegex(SoakError, "state_root"):
+            parse_one_shot(output.rsplit("\n", 1)[0], "fixture")
+
+    def test_evaluate_detects_reset_and_cross_backend_drift(self) -> None:
+        results = {
+            "cpu": [
+                {"iteration": 0, "prompt": "p", "generated": [1]},
+                {"iteration": 1, "prompt": "p", "generated": [2]},
+            ],
+            "gpu": [
+                {"iteration": 0, "prompt": "p", "generated": [1]},
+                {"iteration": 1, "prompt": "p", "generated": [1]},
+            ],
+        }
+        roots = {
+            "cpu": {
+                "generated": [1],
+                "ids_fnv64": "00",
+                "route_root": "11",
+                "kv_root": "22",
+                "state_root": "33",
+            },
+            "gpu": {
+                "generated": [1],
+                "ids_fnv64": "00",
+                "route_root": "11",
+                "kv_root": "22",
+                "state_root": "44",
+            },
+        }
+        kinds = {item["kind"] for item in evaluate(results, roots, ["p"])}
+        self.assertEqual(
+            kinds,
+            {
+                "backend_reset_drift",
+                "cross_backend_tokens",
+                "cross_backend_execution_root",
+            },
+        )
+
+    def test_evaluate_accepts_identical_runs(self) -> None:
+        rows = [
+            {"iteration": 0, "prompt": "p", "generated": [1, 2]},
+            {"iteration": 1, "prompt": "p", "generated": [1, 2]},
+        ]
+        root = {
+            "generated": [1, 2],
+            "ids_fnv64": "00",
+            "route_root": "11",
+            "kv_root": "22",
+            "state_root": "33",
+        }
+        self.assertEqual(
+            evaluate({"cpu": rows, "gpu": list(rows)}, {"cpu": root, "gpu": root}, ["p"]),
+            [],
+        )
+
+    def test_reference_evaluation_binds_source_schedule_and_roots(self) -> None:
+        row = {"iteration": 0, "prompt": "p", "generated": [1, 2]}
+        root = {
+            "generated": [1, 2],
+            "ids_fnv64": "00",
+            "route_root": "11",
+            "kv_root": "22",
+            "state_root": "33",
+        }
+        artifact = {"sha256": "aa"}
+        configuration = {
+            "threads": 8,
+            "max_new": 2,
+            "iterations": 1,
+            "prompts": [{"name": "p", "ids": [3]}],
+        }
+        reference = {
+            "schema": SCHEMA,
+            "passed": True,
+            "_report_sha256": "ff",
+            "host": {"system": "Darwin", "machine": "arm64"},
+            "artifacts": {
+                "model": artifact,
+                "tables": artifact,
+                "source": artifact,
+            },
+            "configuration": configuration,
+            "backends": [{"name": "metal-v3"}],
+            "measurements": {"metal-v3": [row]},
+            "root_checks": {"metal-v3": root},
+        }
+        mismatches, record = evaluate_reference(
+            reference,
+            {"model": artifact, "tables": artifact, "source": artifact},
+            configuration,
+            {"system": "Linux", "machine": "x86_64"},
+            {"cpu": [row]},
+            {"cpu": root},
+        )
+        self.assertEqual(mismatches, [])
+        self.assertEqual(record["report_sha256"], "ff")
+
+        changed = dict(row, generated=[9])
+        mismatches, _ = evaluate_reference(
+            reference,
+            {"model": artifact, "tables": artifact, "source": artifact},
+            configuration,
+            {"system": "Linux", "machine": "x86_64"},
+            {"cpu": [changed]},
+            {"cpu": root},
+        )
+        self.assertIn("cross_host_tokens", {item["kind"] for item in mismatches})
+
+        legacy = dict(reference, schema=LEGACY_UNATTESTED_SCHEMA)
+        with self.assertRaisesRegex(SoakError, "legacy v1"):
+            evaluate_reference(
+                legacy,
+                {"model": artifact, "tables": artifact, "source": artifact},
+                configuration,
+                {"system": "Linux", "machine": "x86_64"},
+                {"cpu": [row]},
+                {"cpu": root},
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()