Qwen3 base no-FiT merge control wb; all9 stages

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_01_merge.json

@@ -0,0 +1,110 @@
+{
+  "cycle": 1,
+  "anchor": 12,
+  "removed_original_layer": 13,
+  "selection_policy": "fixed_our_span_13_22_anchor12",
+  "fit": false,
+  "lambda_left": 0.0,
+  "transport_matrix_sha256": "ea43767088fa2f8cc0b7ba197024635f7b8a7e19fdd34170b499f470c2461672",
+  "transport": {
+    "stats": {
+      "tokens": 65536,
+      "ridge_relative": 0.001,
+      "ridge_absolute": 6.060115993022919e-05,
+      "gram_mean_diagonal": 0.06060115993022919,
+      "calibration_nmse": 0.12798181447783583,
+      "calibration_cosine": 0.9338195359584089,
+      "calibration_norm_ratio": 0.9329591782339236,
+      "transport_relative_identity_distance": 0.4961368441581726,
+      "enabled": true,
+      "batches": 32,
+      "coordinate_fit": "X_anchor @ T ~= X_source",
+      "weight_rewrite": [
+        "mlp.gate_proj.weight <- W_source @ T.T",
+        "mlp.up_proj.weight <- W_source @ T.T"
+      ],
+      "down_proj_transported": false,
+      "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+    },
+    "source_before_sha256": {
+      "self_attn.q_proj.weight": "67540e2474547f1d622b738128696574720591fddabb8157d2f6812ecc3af308",
+      "self_attn.k_proj.weight": "efbe8b71b99ef90277849155ebc45e9aad5ffe746f2958c077c7c7130d783c7b",
+      "self_attn.v_proj.weight": "c53545e1ac9a6447efa83242434a0b28bcda5fe12ef3866e173dd13c3da45e38",
+      "self_attn.o_proj.weight": "8812afef76626e47fb5dffe3a77a0cb07a07e8a7f5cf3a97453368a1284b0ffa",
+      "self_attn.q_norm.weight": "79bbb659cb1c2af322ca85abf7d26b088c837bcd284e70efa95a6449f69b5673",
+      "self_attn.k_norm.weight": "e50a57833625792c16439de078eeb810df393e1a49ef7bbe43f5af6a93923adc",
+      "mlp.gate_proj.weight": "6bc0a4412e6639d40e3a7d5c9099a5a05f2573bd12744019550fc11da2c52c55",
+      "mlp.up_proj.weight": "8715dd4fa81b5d58a577a1b2fdfb24592b23775921014b36f832fe8dbf2bbf51",
+      "mlp.down_proj.weight": "032dc5aba56bd954e7498918ca13b8589c12587c97ad88560480e8d28c18883b",
+      "input_layernorm.weight": "c419d161cc4932ecddf0ec98cbe5737b92688f0d5aa71a7e95d2006ca824ffca",
+      "post_attention_layernorm.weight": "ee6a9a96c2b4f35eb0807060229f10bc28080072ed9ecfa0a17e1aaa3cb4df40"
+    },
+    "source_after_sha256": {
+      "self_attn.q_proj.weight": "67540e2474547f1d622b738128696574720591fddabb8157d2f6812ecc3af308",
+      "self_attn.k_proj.weight": "efbe8b71b99ef90277849155ebc45e9aad5ffe746f2958c077c7c7130d783c7b",
+      "self_attn.v_proj.weight": "c53545e1ac9a6447efa83242434a0b28bcda5fe12ef3866e173dd13c3da45e38",
+      "self_attn.o_proj.weight": "8812afef76626e47fb5dffe3a77a0cb07a07e8a7f5cf3a97453368a1284b0ffa",
+      "self_attn.q_norm.weight": "79bbb659cb1c2af322ca85abf7d26b088c837bcd284e70efa95a6449f69b5673",
+      "self_attn.k_norm.weight": "e50a57833625792c16439de078eeb810df393e1a49ef7bbe43f5af6a93923adc",
+      "mlp.gate_proj.weight": "655a66345118a70ec952e549407ec7f19222782a04bf0db39c5ee8372372a2bf",
+      "mlp.up_proj.weight": "cb86cdbce20a724154f50658e0c2cfc3ec3d63e3802388217035698470825d82",
+      "mlp.down_proj.weight": "032dc5aba56bd954e7498918ca13b8589c12587c97ad88560480e8d28c18883b",
+      "input_layernorm.weight": "c419d161cc4932ecddf0ec98cbe5737b92688f0d5aa71a7e95d2006ca824ffca",
+      "post_attention_layernorm.weight": "ee6a9a96c2b4f35eb0807060229f10bc28080072ed9ecfa0a17e1aaa3cb4df40"
+    },
+    "changed": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight"
+    ]
+  },
+  "merge": {
+    "initializer": "wb",
+    "lambda_left": 0.0,
+    "lambda_right": 1.0,
+    "projection_names": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight",
+      "mlp.down_proj.weight"
+    ],
+    "scope": "mlp",
+    "frozen_anchor_sha256": {
+      "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+      "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+      "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+      "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+      "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+      "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+      "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+      "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+    },
+    "anchor_before_sha256": {
+      "mlp.gate_proj.weight": "3e138d6d890dfaeeeb88ae9b8a48c084aea69752230749e87f1586b975880ddd",
+      "mlp.up_proj.weight": "1f3dacc4c4a3af2a55d6273cfc2374077a2eda18cec7cf8237e05c54cc1b8ea5",
+      "mlp.down_proj.weight": "7a34a8a9bcc1a25c928397e3be5c409081b9de0ec283d13425482c0020e6db43"
+    },
+    "source_post_transport_sha256": {
+      "self_attn.q_proj.weight": "67540e2474547f1d622b738128696574720591fddabb8157d2f6812ecc3af308",
+      "self_attn.k_proj.weight": "efbe8b71b99ef90277849155ebc45e9aad5ffe746f2958c077c7c7130d783c7b",
+      "self_attn.v_proj.weight": "c53545e1ac9a6447efa83242434a0b28bcda5fe12ef3866e173dd13c3da45e38",
+      "self_attn.o_proj.weight": "8812afef76626e47fb5dffe3a77a0cb07a07e8a7f5cf3a97453368a1284b0ffa",
+      "self_attn.q_norm.weight": "79bbb659cb1c2af322ca85abf7d26b088c837bcd284e70efa95a6449f69b5673",
+      "self_attn.k_norm.weight": "e50a57833625792c16439de078eeb810df393e1a49ef7bbe43f5af6a93923adc",
+      "mlp.gate_proj.weight": "655a66345118a70ec952e549407ec7f19222782a04bf0db39c5ee8372372a2bf",
+      "mlp.up_proj.weight": "cb86cdbce20a724154f50658e0c2cfc3ec3d63e3802388217035698470825d82",
+      "mlp.down_proj.weight": "032dc5aba56bd954e7498918ca13b8589c12587c97ad88560480e8d28c18883b",
+      "input_layernorm.weight": "c419d161cc4932ecddf0ec98cbe5737b92688f0d5aa71a7e95d2006ca824ffca",
+      "post_attention_layernorm.weight": "ee6a9a96c2b4f35eb0807060229f10bc28080072ed9ecfa0a17e1aaa3cb4df40"
+    },
+    "anchor_after_sha256": {
+      "mlp.gate_proj.weight": "655a66345118a70ec952e549407ec7f19222782a04bf0db39c5ee8372372a2bf",
+      "mlp.up_proj.weight": "cb86cdbce20a724154f50658e0c2cfc3ec3d63e3802388217035698470825d82",
+      "mlp.down_proj.weight": "032dc5aba56bd954e7498918ca13b8589c12587c97ad88560480e8d28c18883b"
+    },
+    "norm_policy": "keep_Wa_including_QK_norms",
+    "source_mutated_by_merge": false,
+    "fisher_computed": false,
+    "fit": false,
+    "optimizer_steps": 0,
+    "backward_calls": 0
+  }
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_01_transport.pt

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

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_02_merge.json

@@ -0,0 +1,110 @@
+{
+  "cycle": 2,
+  "anchor": 12,
+  "removed_original_layer": 14,
+  "selection_policy": "fixed_our_span_13_22_anchor12",
+  "fit": false,
+  "lambda_left": 0.0,
+  "transport_matrix_sha256": "2f2164ca8bffcf85ff9cfb9506308fa1340559aba7e44bda37d1e050e6e82d36",
+  "transport": {
+    "stats": {
+      "tokens": 65536,
+      "ridge_relative": 0.001,
+      "ridge_absolute": 6.060115993022919e-05,
+      "gram_mean_diagonal": 0.06060115993022919,
+      "calibration_nmse": 0.10099672573787757,
+      "calibration_cosine": 0.9481582440752598,
+      "calibration_norm_ratio": 0.9472741933087646,
+      "transport_relative_identity_distance": 0.45524656772613525,
+      "enabled": true,
+      "batches": 32,
+      "coordinate_fit": "X_anchor @ T ~= X_source",
+      "weight_rewrite": [
+        "mlp.gate_proj.weight <- W_source @ T.T",
+        "mlp.up_proj.weight <- W_source @ T.T"
+      ],
+      "down_proj_transported": false,
+      "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+    },
+    "source_before_sha256": {
+      "self_attn.q_proj.weight": "f57ad388d57bb515af2ac9324d86dc9e19c4cc44bc73879a7b409f9c07597c15",
+      "self_attn.k_proj.weight": "09cba09d72eea6b683087478aeaaf6d321423335a9eb57d47006adbc1f336c63",
+      "self_attn.v_proj.weight": "af4adee7b325a938beb530808104ab27a70afc0d494134b3de1f5ea8ef060773",
+      "self_attn.o_proj.weight": "6888fff18d668ea322341951eb6ab19a3fbbc4cf94b758ed0f8dba411a262d1f",
+      "self_attn.q_norm.weight": "e3e9ec56f12aa5ec410018bbac99e6953ad52f3b8b796d73c5bd0cc6545fb93b",
+      "self_attn.k_norm.weight": "a5bf1576b21d93da019094f1a61912669136a5d9e89e8d2301c88f6bf2def290",
+      "mlp.gate_proj.weight": "1d90e8cf937190e4027f0c7bc34bbabd5bb43c5f3d081537e0d866da8a3efe3f",
+      "mlp.up_proj.weight": "dc867f2d0718d761bb166f69bd21878837006daf9ae392c955a2e9578a15ad97",
+      "mlp.down_proj.weight": "0ac1fc28ab86d85f9cb5f40fbde4485ceac5d2d531a13f5f05d81910ebd8b48d",
+      "input_layernorm.weight": "c21d58d80fa7aca24ff0dac67092f8204b3876926fa095bb7e6ceb3a16060706",
+      "post_attention_layernorm.weight": "1e599b9bd0ed7fdbcef34cff94651bf467bf923745a76a96d33a74ae551ad5d5"
+    },
+    "source_after_sha256": {
+      "self_attn.q_proj.weight": "f57ad388d57bb515af2ac9324d86dc9e19c4cc44bc73879a7b409f9c07597c15",
+      "self_attn.k_proj.weight": "09cba09d72eea6b683087478aeaaf6d321423335a9eb57d47006adbc1f336c63",
+      "self_attn.v_proj.weight": "af4adee7b325a938beb530808104ab27a70afc0d494134b3de1f5ea8ef060773",
+      "self_attn.o_proj.weight": "6888fff18d668ea322341951eb6ab19a3fbbc4cf94b758ed0f8dba411a262d1f",
+      "self_attn.q_norm.weight": "e3e9ec56f12aa5ec410018bbac99e6953ad52f3b8b796d73c5bd0cc6545fb93b",
+      "self_attn.k_norm.weight": "a5bf1576b21d93da019094f1a61912669136a5d9e89e8d2301c88f6bf2def290",
+      "mlp.gate_proj.weight": "f7c92c612a7c8544bac0f0123aff1cb5f922f5b1cf88006c20b8768643f37029",
+      "mlp.up_proj.weight": "4a3522038cb62630906e194bfc0a6e0d5b7f7e8a614b029b83f93145bc4c4a04",
+      "mlp.down_proj.weight": "0ac1fc28ab86d85f9cb5f40fbde4485ceac5d2d531a13f5f05d81910ebd8b48d",
+      "input_layernorm.weight": "c21d58d80fa7aca24ff0dac67092f8204b3876926fa095bb7e6ceb3a16060706",
+      "post_attention_layernorm.weight": "1e599b9bd0ed7fdbcef34cff94651bf467bf923745a76a96d33a74ae551ad5d5"
+    },
+    "changed": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight"
+    ]
+  },
+  "merge": {
+    "initializer": "wb",
+    "lambda_left": 0.0,
+    "lambda_right": 1.0,
+    "projection_names": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight",
+      "mlp.down_proj.weight"
+    ],
+    "scope": "mlp",
+    "frozen_anchor_sha256": {
+      "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+      "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+      "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+      "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+      "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+      "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+      "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+      "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+    },
+    "anchor_before_sha256": {
+      "mlp.gate_proj.weight": "655a66345118a70ec952e549407ec7f19222782a04bf0db39c5ee8372372a2bf",
+      "mlp.up_proj.weight": "cb86cdbce20a724154f50658e0c2cfc3ec3d63e3802388217035698470825d82",
+      "mlp.down_proj.weight": "032dc5aba56bd954e7498918ca13b8589c12587c97ad88560480e8d28c18883b"
+    },
+    "source_post_transport_sha256": {
+      "self_attn.q_proj.weight": "f57ad388d57bb515af2ac9324d86dc9e19c4cc44bc73879a7b409f9c07597c15",
+      "self_attn.k_proj.weight": "09cba09d72eea6b683087478aeaaf6d321423335a9eb57d47006adbc1f336c63",
+      "self_attn.v_proj.weight": "af4adee7b325a938beb530808104ab27a70afc0d494134b3de1f5ea8ef060773",
+      "self_attn.o_proj.weight": "6888fff18d668ea322341951eb6ab19a3fbbc4cf94b758ed0f8dba411a262d1f",
+      "self_attn.q_norm.weight": "e3e9ec56f12aa5ec410018bbac99e6953ad52f3b8b796d73c5bd0cc6545fb93b",
+      "self_attn.k_norm.weight": "a5bf1576b21d93da019094f1a61912669136a5d9e89e8d2301c88f6bf2def290",
+      "mlp.gate_proj.weight": "f7c92c612a7c8544bac0f0123aff1cb5f922f5b1cf88006c20b8768643f37029",
+      "mlp.up_proj.weight": "4a3522038cb62630906e194bfc0a6e0d5b7f7e8a614b029b83f93145bc4c4a04",
+      "mlp.down_proj.weight": "0ac1fc28ab86d85f9cb5f40fbde4485ceac5d2d531a13f5f05d81910ebd8b48d",
+      "input_layernorm.weight": "c21d58d80fa7aca24ff0dac67092f8204b3876926fa095bb7e6ceb3a16060706",
+      "post_attention_layernorm.weight": "1e599b9bd0ed7fdbcef34cff94651bf467bf923745a76a96d33a74ae551ad5d5"
+    },
+    "anchor_after_sha256": {
+      "mlp.gate_proj.weight": "f7c92c612a7c8544bac0f0123aff1cb5f922f5b1cf88006c20b8768643f37029",
+      "mlp.up_proj.weight": "4a3522038cb62630906e194bfc0a6e0d5b7f7e8a614b029b83f93145bc4c4a04",
+      "mlp.down_proj.weight": "0ac1fc28ab86d85f9cb5f40fbde4485ceac5d2d531a13f5f05d81910ebd8b48d"
+    },
+    "norm_policy": "keep_Wa_including_QK_norms",
+    "source_mutated_by_merge": false,
+    "fisher_computed": false,
+    "fit": false,
+    "optimizer_steps": 0,
+    "backward_calls": 0
+  }
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_02_transport.pt

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

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_03_merge.json

@@ -0,0 +1,110 @@
+{
+  "cycle": 3,
+  "anchor": 12,
+  "removed_original_layer": 15,
+  "selection_policy": "fixed_our_span_13_22_anchor12",
+  "fit": false,
+  "lambda_left": 0.0,
+  "transport_matrix_sha256": "c74bae7cb32fe1396e861248ba6bf41c2fd708fc354660e485db8f232fea727e",
+  "transport": {
+    "stats": {
+      "tokens": 65536,
+      "ridge_relative": 0.001,
+      "ridge_absolute": 6.060115993022919e-05,
+      "gram_mean_diagonal": 0.06060115993022919,
+      "calibration_nmse": 0.11038890826345682,
+      "calibration_cosine": 0.9431923979113933,
+      "calibration_norm_ratio": 0.9422936536202322,
+      "transport_relative_identity_distance": 0.480193167924881,
+      "enabled": true,
+      "batches": 32,
+      "coordinate_fit": "X_anchor @ T ~= X_source",
+      "weight_rewrite": [
+        "mlp.gate_proj.weight <- W_source @ T.T",
+        "mlp.up_proj.weight <- W_source @ T.T"
+      ],
+      "down_proj_transported": false,
+      "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+    },
+    "source_before_sha256": {
+      "self_attn.q_proj.weight": "6005f741b04aefb4b83452f774f7d013b010b6218020e382a98c92a45d8878ac",
+      "self_attn.k_proj.weight": "e4d7d1464c351cfcb69799eb3e3bf63cc597383cbfb0d07263236ba2d8eb3d5b",
+      "self_attn.v_proj.weight": "25063dfdce05fdcb1a48c5d71c3e0107d7a894b7fb6c0f7defa2e768c68ba3d7",
+      "self_attn.o_proj.weight": "e96bf888e3b0629075b2ee05288e147fd875119467d978c2269ecfeb3b0db4eb",
+      "self_attn.q_norm.weight": "d77168c19fe27a0d64a2611360be089b4435adc62444d0e82a986419be1d9b44",
+      "self_attn.k_norm.weight": "2cbb9d53874b3fe1d350a9c9031d64cd138a1dbac549529d07da2927106a10ff",
+      "mlp.gate_proj.weight": "3acdf3c7c3b8dd224f2837ef92c5e72e8bc7963baa021e9ba2a032da6084c86a",
+      "mlp.up_proj.weight": "6a0bdd43c6eab5e133991697799089710e9077591b56bcbde02440054dbfebbc",
+      "mlp.down_proj.weight": "1f66d7843032883982c0b98e73d9193144e181de07f5506b718d1cea3edb23ea",
+      "input_layernorm.weight": "3f2e5d516a4c80f8d93f0221e5ecbc2e7e692f111118c7c629f210ee9d03419d",
+      "post_attention_layernorm.weight": "3a237234fa5182946c09967a08faec9d9060f4bd780bdd6627f6159edebe2f98"
+    },
+    "source_after_sha256": {
+      "self_attn.q_proj.weight": "6005f741b04aefb4b83452f774f7d013b010b6218020e382a98c92a45d8878ac",
+      "self_attn.k_proj.weight": "e4d7d1464c351cfcb69799eb3e3bf63cc597383cbfb0d07263236ba2d8eb3d5b",
+      "self_attn.v_proj.weight": "25063dfdce05fdcb1a48c5d71c3e0107d7a894b7fb6c0f7defa2e768c68ba3d7",
+      "self_attn.o_proj.weight": "e96bf888e3b0629075b2ee05288e147fd875119467d978c2269ecfeb3b0db4eb",
+      "self_attn.q_norm.weight": "d77168c19fe27a0d64a2611360be089b4435adc62444d0e82a986419be1d9b44",
+      "self_attn.k_norm.weight": "2cbb9d53874b3fe1d350a9c9031d64cd138a1dbac549529d07da2927106a10ff",
+      "mlp.gate_proj.weight": "8292c665701ba7b813c028746607fae674b14b68899c1b53243212237e3d7d2c",
+      "mlp.up_proj.weight": "17669eaa9229e48a498c1cc80e87be7605a037083184521ca6ab99b277bfa6d2",
+      "mlp.down_proj.weight": "1f66d7843032883982c0b98e73d9193144e181de07f5506b718d1cea3edb23ea",
+      "input_layernorm.weight": "3f2e5d516a4c80f8d93f0221e5ecbc2e7e692f111118c7c629f210ee9d03419d",
+      "post_attention_layernorm.weight": "3a237234fa5182946c09967a08faec9d9060f4bd780bdd6627f6159edebe2f98"
+    },
+    "changed": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight"
+    ]
+  },
+  "merge": {
+    "initializer": "wb",
+    "lambda_left": 0.0,
+    "lambda_right": 1.0,
+    "projection_names": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight",
+      "mlp.down_proj.weight"
+    ],
+    "scope": "mlp",
+    "frozen_anchor_sha256": {
+      "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+      "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+      "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+      "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+      "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+      "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+      "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+      "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+    },
+    "anchor_before_sha256": {
+      "mlp.gate_proj.weight": "f7c92c612a7c8544bac0f0123aff1cb5f922f5b1cf88006c20b8768643f37029",
+      "mlp.up_proj.weight": "4a3522038cb62630906e194bfc0a6e0d5b7f7e8a614b029b83f93145bc4c4a04",
+      "mlp.down_proj.weight": "0ac1fc28ab86d85f9cb5f40fbde4485ceac5d2d531a13f5f05d81910ebd8b48d"
+    },
+    "source_post_transport_sha256": {
+      "self_attn.q_proj.weight": "6005f741b04aefb4b83452f774f7d013b010b6218020e382a98c92a45d8878ac",
+      "self_attn.k_proj.weight": "e4d7d1464c351cfcb69799eb3e3bf63cc597383cbfb0d07263236ba2d8eb3d5b",
+      "self_attn.v_proj.weight": "25063dfdce05fdcb1a48c5d71c3e0107d7a894b7fb6c0f7defa2e768c68ba3d7",
+      "self_attn.o_proj.weight": "e96bf888e3b0629075b2ee05288e147fd875119467d978c2269ecfeb3b0db4eb",
+      "self_attn.q_norm.weight": "d77168c19fe27a0d64a2611360be089b4435adc62444d0e82a986419be1d9b44",
+      "self_attn.k_norm.weight": "2cbb9d53874b3fe1d350a9c9031d64cd138a1dbac549529d07da2927106a10ff",
+      "mlp.gate_proj.weight": "8292c665701ba7b813c028746607fae674b14b68899c1b53243212237e3d7d2c",
+      "mlp.up_proj.weight": "17669eaa9229e48a498c1cc80e87be7605a037083184521ca6ab99b277bfa6d2",
+      "mlp.down_proj.weight": "1f66d7843032883982c0b98e73d9193144e181de07f5506b718d1cea3edb23ea",
+      "input_layernorm.weight": "3f2e5d516a4c80f8d93f0221e5ecbc2e7e692f111118c7c629f210ee9d03419d",
+      "post_attention_layernorm.weight": "3a237234fa5182946c09967a08faec9d9060f4bd780bdd6627f6159edebe2f98"
+    },
+    "anchor_after_sha256": {
+      "mlp.gate_proj.weight": "8292c665701ba7b813c028746607fae674b14b68899c1b53243212237e3d7d2c",
+      "mlp.up_proj.weight": "17669eaa9229e48a498c1cc80e87be7605a037083184521ca6ab99b277bfa6d2",
+      "mlp.down_proj.weight": "1f66d7843032883982c0b98e73d9193144e181de07f5506b718d1cea3edb23ea"
+    },
+    "norm_policy": "keep_Wa_including_QK_norms",
+    "source_mutated_by_merge": false,
+    "fisher_computed": false,
+    "fit": false,
+    "optimizer_steps": 0,
+    "backward_calls": 0
+  }
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_03_transport.pt

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

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_04_merge.json

@@ -0,0 +1,110 @@
+{
+  "cycle": 4,
+  "anchor": 12,
+  "removed_original_layer": 16,
+  "selection_policy": "fixed_our_span_13_22_anchor12",
+  "fit": false,
+  "lambda_left": 0.0,
+  "transport_matrix_sha256": "49bbea5f7162f9479174a850b673f69481d7c2e8e01b01c5a110ec706d662fce",
+  "transport": {
+    "stats": {
+      "tokens": 65536,
+      "ridge_relative": 0.001,
+      "ridge_absolute": 6.060115993022919e-05,
+      "gram_mean_diagonal": 0.06060115993022919,
+      "calibration_nmse": 0.09866496995725485,
+      "calibration_cosine": 0.9493870783680597,
+      "calibration_norm_ratio": 0.9484957145281611,
+      "transport_relative_identity_distance": 0.46458062529563904,
+      "enabled": true,
+      "batches": 32,
+      "coordinate_fit": "X_anchor @ T ~= X_source",
+      "weight_rewrite": [
+        "mlp.gate_proj.weight <- W_source @ T.T",
+        "mlp.up_proj.weight <- W_source @ T.T"
+      ],
+      "down_proj_transported": false,
+      "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+    },
+    "source_before_sha256": {
+      "self_attn.q_proj.weight": "a9874967bd53acfd480ed2bd5552fab4e1a06f610af242d411e176c279e0191a",
+      "self_attn.k_proj.weight": "0a285bc594b54a921f698937c566bce629295ff4befcebb203038dd0d97eb3f0",
+      "self_attn.v_proj.weight": "dd8847c5b10e200df29bf79b30321ec7f1d90427ab9b3d273e18a4cbd83e597d",
+      "self_attn.o_proj.weight": "e6afd2a9ba7c9e6f1911d773062b9d37442a01ead339c9aa9255ff20f146b196",
+      "self_attn.q_norm.weight": "48de60cd86dec981224231f275146bc8d17990394835783504bbf5f0e9c5bb1a",
+      "self_attn.k_norm.weight": "d6ef88be0fc007a2bc5e9f1a0a70b7eac493495b5b54b4f72582378340b9bb4d",
+      "mlp.gate_proj.weight": "171beb5701a83f117d0a59a14a78be2936a062c7aa5700ec39efd9c816af96db",
+      "mlp.up_proj.weight": "e04d543903d934aae9062d2034f71ac4d3fb1ac69bd5f31d365f404c764e535e",
+      "mlp.down_proj.weight": "c297d40f8af2ed96c90ff2f616877b4aaeed4bc2918f0e3b56ea769203724ce1",
+      "input_layernorm.weight": "45d58615dedc0906944d998c52fed1d0d139338362abd51fc1b98ae12edec92a",
+      "post_attention_layernorm.weight": "af332049d823017194704880c92765ab0cf4a519c8819753d0539106ea951cef"
+    },
+    "source_after_sha256": {
+      "self_attn.q_proj.weight": "a9874967bd53acfd480ed2bd5552fab4e1a06f610af242d411e176c279e0191a",
+      "self_attn.k_proj.weight": "0a285bc594b54a921f698937c566bce629295ff4befcebb203038dd0d97eb3f0",
+      "self_attn.v_proj.weight": "dd8847c5b10e200df29bf79b30321ec7f1d90427ab9b3d273e18a4cbd83e597d",
+      "self_attn.o_proj.weight": "e6afd2a9ba7c9e6f1911d773062b9d37442a01ead339c9aa9255ff20f146b196",
+      "self_attn.q_norm.weight": "48de60cd86dec981224231f275146bc8d17990394835783504bbf5f0e9c5bb1a",
+      "self_attn.k_norm.weight": "d6ef88be0fc007a2bc5e9f1a0a70b7eac493495b5b54b4f72582378340b9bb4d",
+      "mlp.gate_proj.weight": "debf2f81470433f78676cc9649af3a208c369737428e6fcf4918ef2f14edeb9b",
+      "mlp.up_proj.weight": "5c1a4ef2663bb8509c1736405a121d2cf0105b113be03629fdd9c8ebae51064a",
+      "mlp.down_proj.weight": "c297d40f8af2ed96c90ff2f616877b4aaeed4bc2918f0e3b56ea769203724ce1",
+      "input_layernorm.weight": "45d58615dedc0906944d998c52fed1d0d139338362abd51fc1b98ae12edec92a",
+      "post_attention_layernorm.weight": "af332049d823017194704880c92765ab0cf4a519c8819753d0539106ea951cef"
+    },
+    "changed": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight"
+    ]
+  },
+  "merge": {
+    "initializer": "wb",
+    "lambda_left": 0.0,
+    "lambda_right": 1.0,
+    "projection_names": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight",
+      "mlp.down_proj.weight"
+    ],
+    "scope": "mlp",
+    "frozen_anchor_sha256": {
+      "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+      "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+      "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+      "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+      "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+      "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+      "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+      "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+    },
+    "anchor_before_sha256": {
+      "mlp.gate_proj.weight": "8292c665701ba7b813c028746607fae674b14b68899c1b53243212237e3d7d2c",
+      "mlp.up_proj.weight": "17669eaa9229e48a498c1cc80e87be7605a037083184521ca6ab99b277bfa6d2",
+      "mlp.down_proj.weight": "1f66d7843032883982c0b98e73d9193144e181de07f5506b718d1cea3edb23ea"
+    },
+    "source_post_transport_sha256": {
+      "self_attn.q_proj.weight": "a9874967bd53acfd480ed2bd5552fab4e1a06f610af242d411e176c279e0191a",
+      "self_attn.k_proj.weight": "0a285bc594b54a921f698937c566bce629295ff4befcebb203038dd0d97eb3f0",
+      "self_attn.v_proj.weight": "dd8847c5b10e200df29bf79b30321ec7f1d90427ab9b3d273e18a4cbd83e597d",
+      "self_attn.o_proj.weight": "e6afd2a9ba7c9e6f1911d773062b9d37442a01ead339c9aa9255ff20f146b196",
+      "self_attn.q_norm.weight": "48de60cd86dec981224231f275146bc8d17990394835783504bbf5f0e9c5bb1a",
+      "self_attn.k_norm.weight": "d6ef88be0fc007a2bc5e9f1a0a70b7eac493495b5b54b4f72582378340b9bb4d",
+      "mlp.gate_proj.weight": "debf2f81470433f78676cc9649af3a208c369737428e6fcf4918ef2f14edeb9b",
+      "mlp.up_proj.weight": "5c1a4ef2663bb8509c1736405a121d2cf0105b113be03629fdd9c8ebae51064a",
+      "mlp.down_proj.weight": "c297d40f8af2ed96c90ff2f616877b4aaeed4bc2918f0e3b56ea769203724ce1",
+      "input_layernorm.weight": "45d58615dedc0906944d998c52fed1d0d139338362abd51fc1b98ae12edec92a",
+      "post_attention_layernorm.weight": "af332049d823017194704880c92765ab0cf4a519c8819753d0539106ea951cef"
+    },
+    "anchor_after_sha256": {
+      "mlp.gate_proj.weight": "debf2f81470433f78676cc9649af3a208c369737428e6fcf4918ef2f14edeb9b",
+      "mlp.up_proj.weight": "5c1a4ef2663bb8509c1736405a121d2cf0105b113be03629fdd9c8ebae51064a",
+      "mlp.down_proj.weight": "c297d40f8af2ed96c90ff2f616877b4aaeed4bc2918f0e3b56ea769203724ce1"
+    },
+    "norm_policy": "keep_Wa_including_QK_norms",
+    "source_mutated_by_merge": false,
+    "fisher_computed": false,
+    "fit": false,
+    "optimizer_steps": 0,
+    "backward_calls": 0
+  }
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_04_transport.pt

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

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_05_merge.json

@@ -0,0 +1,110 @@
+{
+  "cycle": 5,
+  "anchor": 12,
+  "removed_original_layer": 17,
+  "selection_policy": "fixed_our_span_13_22_anchor12",
+  "fit": false,
+  "lambda_left": 0.0,
+  "transport_matrix_sha256": "b968cc0681a32eab25ab339122b95bf8f1b90e3ced55b7638652d052fbcdbcc3",
+  "transport": {
+    "stats": {
+      "tokens": 65536,
+      "ridge_relative": 0.001,
+      "ridge_absolute": 6.060115993022919e-05,
+      "gram_mean_diagonal": 0.06060115993022919,
+      "calibration_nmse": 0.09917833468174767,
+      "calibration_cosine": 0.9491166565617855,
+      "calibration_norm_ratio": 0.9482434757273703,
+      "transport_relative_identity_distance": 0.4882379472255707,
+      "enabled": true,
+      "batches": 32,
+      "coordinate_fit": "X_anchor @ T ~= X_source",
+      "weight_rewrite": [
+        "mlp.gate_proj.weight <- W_source @ T.T",
+        "mlp.up_proj.weight <- W_source @ T.T"
+      ],
+      "down_proj_transported": false,
+      "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+    },
+    "source_before_sha256": {
+      "self_attn.q_proj.weight": "93af1649dbcf27dcc906cff079a1448af3e0b78dc0ae7fcd0038e95d05f79fdc",
+      "self_attn.k_proj.weight": "919f1a2454b2957fa1f611232b1c0aaccdab718aed512b435923cf972cd52015",
+      "self_attn.v_proj.weight": "2a660e851663561147921fae640f303f3f599da61afc8d68545fed320cc9b63d",
+      "self_attn.o_proj.weight": "bfb11d528abdacfc054070ed7a55f90ddde74fb17704bc742ceffa065adcc717",
+      "self_attn.q_norm.weight": "a4538fa22891825dbfbac330127ff29569ac04b5ab0ee89e60db7e7bc64f26a3",
+      "self_attn.k_norm.weight": "f26654e4f51003513e7ff0cd2f23e99387481dc5c639b01444903ec9632ae685",
+      "mlp.gate_proj.weight": "1ec134d886ea6246b31de9cb6cbb4c451fddfb333fca1e90375f8659eb27d81c",
+      "mlp.up_proj.weight": "b7549bcdd3b5089f09aebb1847587e2049463294f52f4335b88b7e64888edd45",
+      "mlp.down_proj.weight": "2b6fe52a74f5b15de22764a2c9b51acdfc75070dac110580366d2dcd9d207e0f",
+      "input_layernorm.weight": "70025e492885453112e0108ebf4311dfd994db35383e90da14292277834fb949",
+      "post_attention_layernorm.weight": "41357e377104509608d219bc3f4d8a51dde14749a9a6e6b592f6d4f4594faa85"
+    },
+    "source_after_sha256": {
+      "self_attn.q_proj.weight": "93af1649dbcf27dcc906cff079a1448af3e0b78dc0ae7fcd0038e95d05f79fdc",
+      "self_attn.k_proj.weight": "919f1a2454b2957fa1f611232b1c0aaccdab718aed512b435923cf972cd52015",
+      "self_attn.v_proj.weight": "2a660e851663561147921fae640f303f3f599da61afc8d68545fed320cc9b63d",
+      "self_attn.o_proj.weight": "bfb11d528abdacfc054070ed7a55f90ddde74fb17704bc742ceffa065adcc717",
+      "self_attn.q_norm.weight": "a4538fa22891825dbfbac330127ff29569ac04b5ab0ee89e60db7e7bc64f26a3",
+      "self_attn.k_norm.weight": "f26654e4f51003513e7ff0cd2f23e99387481dc5c639b01444903ec9632ae685",
+      "mlp.gate_proj.weight": "98ca3a1f76218aabde9d2dfeb23e28d798f812a336974e190ebaea9076ad4554",
+      "mlp.up_proj.weight": "91405003b4d46ce3a325e27da1f747b7b268d7570d3f6dab4f714a73aae768e6",
+      "mlp.down_proj.weight": "2b6fe52a74f5b15de22764a2c9b51acdfc75070dac110580366d2dcd9d207e0f",
+      "input_layernorm.weight": "70025e492885453112e0108ebf4311dfd994db35383e90da14292277834fb949",
+      "post_attention_layernorm.weight": "41357e377104509608d219bc3f4d8a51dde14749a9a6e6b592f6d4f4594faa85"
+    },
+    "changed": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight"
+    ]
+  },
+  "merge": {
+    "initializer": "wb",
+    "lambda_left": 0.0,
+    "lambda_right": 1.0,
+    "projection_names": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight",
+      "mlp.down_proj.weight"
+    ],
+    "scope": "mlp",
+    "frozen_anchor_sha256": {
+      "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+      "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+      "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+      "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+      "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+      "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+      "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+      "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+    },
+    "anchor_before_sha256": {
+      "mlp.gate_proj.weight": "debf2f81470433f78676cc9649af3a208c369737428e6fcf4918ef2f14edeb9b",
+      "mlp.up_proj.weight": "5c1a4ef2663bb8509c1736405a121d2cf0105b113be03629fdd9c8ebae51064a",
+      "mlp.down_proj.weight": "c297d40f8af2ed96c90ff2f616877b4aaeed4bc2918f0e3b56ea769203724ce1"
+    },
+    "source_post_transport_sha256": {
+      "self_attn.q_proj.weight": "93af1649dbcf27dcc906cff079a1448af3e0b78dc0ae7fcd0038e95d05f79fdc",
+      "self_attn.k_proj.weight": "919f1a2454b2957fa1f611232b1c0aaccdab718aed512b435923cf972cd52015",
+      "self_attn.v_proj.weight": "2a660e851663561147921fae640f303f3f599da61afc8d68545fed320cc9b63d",
+      "self_attn.o_proj.weight": "bfb11d528abdacfc054070ed7a55f90ddde74fb17704bc742ceffa065adcc717",
+      "self_attn.q_norm.weight": "a4538fa22891825dbfbac330127ff29569ac04b5ab0ee89e60db7e7bc64f26a3",
+      "self_attn.k_norm.weight": "f26654e4f51003513e7ff0cd2f23e99387481dc5c639b01444903ec9632ae685",
+      "mlp.gate_proj.weight": "98ca3a1f76218aabde9d2dfeb23e28d798f812a336974e190ebaea9076ad4554",
+      "mlp.up_proj.weight": "91405003b4d46ce3a325e27da1f747b7b268d7570d3f6dab4f714a73aae768e6",
+      "mlp.down_proj.weight": "2b6fe52a74f5b15de22764a2c9b51acdfc75070dac110580366d2dcd9d207e0f",
+      "input_layernorm.weight": "70025e492885453112e0108ebf4311dfd994db35383e90da14292277834fb949",
+      "post_attention_layernorm.weight": "41357e377104509608d219bc3f4d8a51dde14749a9a6e6b592f6d4f4594faa85"
+    },
+    "anchor_after_sha256": {
+      "mlp.gate_proj.weight": "98ca3a1f76218aabde9d2dfeb23e28d798f812a336974e190ebaea9076ad4554",
+      "mlp.up_proj.weight": "91405003b4d46ce3a325e27da1f747b7b268d7570d3f6dab4f714a73aae768e6",
+      "mlp.down_proj.weight": "2b6fe52a74f5b15de22764a2c9b51acdfc75070dac110580366d2dcd9d207e0f"
+    },
+    "norm_policy": "keep_Wa_including_QK_norms",
+    "source_mutated_by_merge": false,
+    "fisher_computed": false,
+    "fit": false,
+    "optimizer_steps": 0,
+    "backward_calls": 0
+  }
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_05_transport.pt

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

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_06_merge.json

@@ -0,0 +1,110 @@
+{
+  "cycle": 6,
+  "anchor": 12,
+  "removed_original_layer": 18,
+  "selection_policy": "fixed_our_span_13_22_anchor12",
+  "fit": false,
+  "lambda_left": 0.0,
+  "transport_matrix_sha256": "b1c313ea0a3aa1df29a0618ae2ef9e5bc49705d8fb26ca876cad9c127db74e9e",
+  "transport": {
+    "stats": {
+      "tokens": 65536,
+      "ridge_relative": 0.001,
+      "ridge_absolute": 6.060115993022919e-05,
+      "gram_mean_diagonal": 0.06060115993022919,
+      "calibration_nmse": 0.09820423130187533,
+      "calibration_cosine": 0.9496297005441647,
+      "calibration_norm_ratio": 0.9487355766850942,
+      "transport_relative_identity_distance": 0.48003679513931274,
+      "enabled": true,
+      "batches": 32,
+      "coordinate_fit": "X_anchor @ T ~= X_source",
+      "weight_rewrite": [
+        "mlp.gate_proj.weight <- W_source @ T.T",
+        "mlp.up_proj.weight <- W_source @ T.T"
+      ],
+      "down_proj_transported": false,
+      "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+    },
+    "source_before_sha256": {
+      "self_attn.q_proj.weight": "3d50a07d21693613e0d831209868828215164c78606ad76bb5339d0093e2b167",
+      "self_attn.k_proj.weight": "055922b3d6d8ae628f8a4761be8273b2b35bd979a899e599e03a4aebc9b31b15",
+      "self_attn.v_proj.weight": "35d50fc9ef07106a763c826a6bed55f5f8de393edeac002703ab161116d8dead",
+      "self_attn.o_proj.weight": "a211c679b699b735e0587b7e0bab5610d182a4c54868438be766544a8f36b4eb",
+      "self_attn.q_norm.weight": "41ed057917753085abc49146d705c39743047800a2ac65dba3e227fb675ad494",
+      "self_attn.k_norm.weight": "f01c939b42b6e7b3a03519eadb0a08a563897458717fc05d98b7c7d158621f02",
+      "mlp.gate_proj.weight": "a60ac64753890f45bc06d840148fad55807f022c4f14d6437d926bfe08d6e401",
+      "mlp.up_proj.weight": "f614342e9f77c5b73e0b93c34e9a6cbfb1692decfd132853765e9da75c5a2edc",
+      "mlp.down_proj.weight": "b61bbddd0e5ee13e6679fb129a28885d063105955f6cb5176c39b0ac18fbfda7",
+      "input_layernorm.weight": "2c7f7059994a701ae1bfd696bd109340fa7a22df9deee3bfd6c4afb890155523",
+      "post_attention_layernorm.weight": "d85cdb5cf77b8d6d42c74fbd6aff643661b72fcfbe4f343311c4d31db4afc67f"
+    },
+    "source_after_sha256": {
+      "self_attn.q_proj.weight": "3d50a07d21693613e0d831209868828215164c78606ad76bb5339d0093e2b167",
+      "self_attn.k_proj.weight": "055922b3d6d8ae628f8a4761be8273b2b35bd979a899e599e03a4aebc9b31b15",
+      "self_attn.v_proj.weight": "35d50fc9ef07106a763c826a6bed55f5f8de393edeac002703ab161116d8dead",
+      "self_attn.o_proj.weight": "a211c679b699b735e0587b7e0bab5610d182a4c54868438be766544a8f36b4eb",
+      "self_attn.q_norm.weight": "41ed057917753085abc49146d705c39743047800a2ac65dba3e227fb675ad494",
+      "self_attn.k_norm.weight": "f01c939b42b6e7b3a03519eadb0a08a563897458717fc05d98b7c7d158621f02",
+      "mlp.gate_proj.weight": "03eb425fe1ff0c465accdbd062fa76ec3b951f4c173d9f900657e922811eff2f",
+      "mlp.up_proj.weight": "f482573a958623f2511b60e6bfdb8ddf1b18a35942833a3cf2f6036131673c06",
+      "mlp.down_proj.weight": "b61bbddd0e5ee13e6679fb129a28885d063105955f6cb5176c39b0ac18fbfda7",
+      "input_layernorm.weight": "2c7f7059994a701ae1bfd696bd109340fa7a22df9deee3bfd6c4afb890155523",
+      "post_attention_layernorm.weight": "d85cdb5cf77b8d6d42c74fbd6aff643661b72fcfbe4f343311c4d31db4afc67f"
+    },
+    "changed": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight"
+    ]
+  },
+  "merge": {
+    "initializer": "wb",
+    "lambda_left": 0.0,
+    "lambda_right": 1.0,
+    "projection_names": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight",
+      "mlp.down_proj.weight"
+    ],
+    "scope": "mlp",
+    "frozen_anchor_sha256": {
+      "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+      "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+      "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+      "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+      "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+      "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+      "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+      "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+    },
+    "anchor_before_sha256": {
+      "mlp.gate_proj.weight": "98ca3a1f76218aabde9d2dfeb23e28d798f812a336974e190ebaea9076ad4554",
+      "mlp.up_proj.weight": "91405003b4d46ce3a325e27da1f747b7b268d7570d3f6dab4f714a73aae768e6",
+      "mlp.down_proj.weight": "2b6fe52a74f5b15de22764a2c9b51acdfc75070dac110580366d2dcd9d207e0f"
+    },
+    "source_post_transport_sha256": {
+      "self_attn.q_proj.weight": "3d50a07d21693613e0d831209868828215164c78606ad76bb5339d0093e2b167",
+      "self_attn.k_proj.weight": "055922b3d6d8ae628f8a4761be8273b2b35bd979a899e599e03a4aebc9b31b15",
+      "self_attn.v_proj.weight": "35d50fc9ef07106a763c826a6bed55f5f8de393edeac002703ab161116d8dead",
+      "self_attn.o_proj.weight": "a211c679b699b735e0587b7e0bab5610d182a4c54868438be766544a8f36b4eb",
+      "self_attn.q_norm.weight": "41ed057917753085abc49146d705c39743047800a2ac65dba3e227fb675ad494",
+      "self_attn.k_norm.weight": "f01c939b42b6e7b3a03519eadb0a08a563897458717fc05d98b7c7d158621f02",
+      "mlp.gate_proj.weight": "03eb425fe1ff0c465accdbd062fa76ec3b951f4c173d9f900657e922811eff2f",
+      "mlp.up_proj.weight": "f482573a958623f2511b60e6bfdb8ddf1b18a35942833a3cf2f6036131673c06",
+      "mlp.down_proj.weight": "b61bbddd0e5ee13e6679fb129a28885d063105955f6cb5176c39b0ac18fbfda7",
+      "input_layernorm.weight": "2c7f7059994a701ae1bfd696bd109340fa7a22df9deee3bfd6c4afb890155523",
+      "post_attention_layernorm.weight": "d85cdb5cf77b8d6d42c74fbd6aff643661b72fcfbe4f343311c4d31db4afc67f"
+    },
+    "anchor_after_sha256": {
+      "mlp.gate_proj.weight": "03eb425fe1ff0c465accdbd062fa76ec3b951f4c173d9f900657e922811eff2f",
+      "mlp.up_proj.weight": "f482573a958623f2511b60e6bfdb8ddf1b18a35942833a3cf2f6036131673c06",
+      "mlp.down_proj.weight": "b61bbddd0e5ee13e6679fb129a28885d063105955f6cb5176c39b0ac18fbfda7"
+    },
+    "norm_policy": "keep_Wa_including_QK_norms",
+    "source_mutated_by_merge": false,
+    "fisher_computed": false,
+    "fit": false,
+    "optimizer_steps": 0,
+    "backward_calls": 0
+  }
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_06_transport.pt

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

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_07_merge.json

@@ -0,0 +1,110 @@
+{
+  "cycle": 7,
+  "anchor": 12,
+  "removed_original_layer": 19,
+  "selection_policy": "fixed_our_span_13_22_anchor12",
+  "fit": false,
+  "lambda_left": 0.0,
+  "transport_matrix_sha256": "4b807a71a3f5c920f7bbe9842c8bc0c89de7ebf5b02893847374cb46eeebbaae",
+  "transport": {
+    "stats": {
+      "tokens": 65536,
+      "ridge_relative": 0.001,
+      "ridge_absolute": 6.060115993022919e-05,
+      "gram_mean_diagonal": 0.06060115993022919,
+      "calibration_nmse": 0.103606409701293,
+      "calibration_cosine": 0.9467810247760247,
+      "calibration_norm_ratio": 0.9459333354270779,
+      "transport_relative_identity_distance": 0.5275545120239258,
+      "enabled": true,
+      "batches": 32,
+      "coordinate_fit": "X_anchor @ T ~= X_source",
+      "weight_rewrite": [
+        "mlp.gate_proj.weight <- W_source @ T.T",
+        "mlp.up_proj.weight <- W_source @ T.T"
+      ],
+      "down_proj_transported": false,
+      "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+    },
+    "source_before_sha256": {
+      "self_attn.q_proj.weight": "d14bc25171528405c3db791fd017b4e0fe37d06a9b07a9878cb81c1f0eb98ae6",
+      "self_attn.k_proj.weight": "8911d7363eb8d7e35ff407ac925183a06d54d624a8d2bd0ff41db97423515a54",
+      "self_attn.v_proj.weight": "4781046a7d6224a77c3e34dda92a2ef5748eb777d9d554acf5621c4e5742be2a",
+      "self_attn.o_proj.weight": "90f47fc1bc507ddfad16299dfcecb78a6b4efac01e21d3a6402c6ef3eae56348",
+      "self_attn.q_norm.weight": "6915d87fcc2402518b382dee5f5929f5774006c5d82904db327d2f118d6a5c99",
+      "self_attn.k_norm.weight": "cb20faa93398541fe6b2fbda2a527ea3243337db753acebdfd045bf309cbc4ae",
+      "mlp.gate_proj.weight": "aaf6792caf14dc5a810bfa937c966c7989238e23b21080752c784428eedbf79c",
+      "mlp.up_proj.weight": "5a9cf857484fc35820ab3032e13383687631e54fc1a7c7ff0443ec36e962cf17",
+      "mlp.down_proj.weight": "d65d2b30d50eb54acafa83fef24d9a0fa7d57b6cb6cc06a94e476c758f8812d6",
+      "input_layernorm.weight": "316472831e20dec19263b56944811a059efb241cc842d8ace4fce706c98a8b11",
+      "post_attention_layernorm.weight": "7a462c4c15d73900fe1275d32448251905112e9530f615fe6776622c416f0f52"
+    },
+    "source_after_sha256": {
+      "self_attn.q_proj.weight": "d14bc25171528405c3db791fd017b4e0fe37d06a9b07a9878cb81c1f0eb98ae6",
+      "self_attn.k_proj.weight": "8911d7363eb8d7e35ff407ac925183a06d54d624a8d2bd0ff41db97423515a54",
+      "self_attn.v_proj.weight": "4781046a7d6224a77c3e34dda92a2ef5748eb777d9d554acf5621c4e5742be2a",
+      "self_attn.o_proj.weight": "90f47fc1bc507ddfad16299dfcecb78a6b4efac01e21d3a6402c6ef3eae56348",
+      "self_attn.q_norm.weight": "6915d87fcc2402518b382dee5f5929f5774006c5d82904db327d2f118d6a5c99",
+      "self_attn.k_norm.weight": "cb20faa93398541fe6b2fbda2a527ea3243337db753acebdfd045bf309cbc4ae",
+      "mlp.gate_proj.weight": "06d454e81788e8cfd28f613250c2c97f44fd78227c38bd35429f19915cdaeb51",
+      "mlp.up_proj.weight": "2c58e52893c9f2de1310538074a6ec2700403d256286f410d59a25064527f6c2",
+      "mlp.down_proj.weight": "d65d2b30d50eb54acafa83fef24d9a0fa7d57b6cb6cc06a94e476c758f8812d6",
+      "input_layernorm.weight": "316472831e20dec19263b56944811a059efb241cc842d8ace4fce706c98a8b11",
+      "post_attention_layernorm.weight": "7a462c4c15d73900fe1275d32448251905112e9530f615fe6776622c416f0f52"
+    },
+    "changed": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight"
+    ]
+  },
+  "merge": {
+    "initializer": "wb",
+    "lambda_left": 0.0,
+    "lambda_right": 1.0,
+    "projection_names": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight",
+      "mlp.down_proj.weight"
+    ],
+    "scope": "mlp",
+    "frozen_anchor_sha256": {
+      "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+      "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+      "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+      "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+      "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+      "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+      "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+      "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+    },
+    "anchor_before_sha256": {
+      "mlp.gate_proj.weight": "03eb425fe1ff0c465accdbd062fa76ec3b951f4c173d9f900657e922811eff2f",
+      "mlp.up_proj.weight": "f482573a958623f2511b60e6bfdb8ddf1b18a35942833a3cf2f6036131673c06",
+      "mlp.down_proj.weight": "b61bbddd0e5ee13e6679fb129a28885d063105955f6cb5176c39b0ac18fbfda7"
+    },
+    "source_post_transport_sha256": {
+      "self_attn.q_proj.weight": "d14bc25171528405c3db791fd017b4e0fe37d06a9b07a9878cb81c1f0eb98ae6",
+      "self_attn.k_proj.weight": "8911d7363eb8d7e35ff407ac925183a06d54d624a8d2bd0ff41db97423515a54",
+      "self_attn.v_proj.weight": "4781046a7d6224a77c3e34dda92a2ef5748eb777d9d554acf5621c4e5742be2a",
+      "self_attn.o_proj.weight": "90f47fc1bc507ddfad16299dfcecb78a6b4efac01e21d3a6402c6ef3eae56348",
+      "self_attn.q_norm.weight": "6915d87fcc2402518b382dee5f5929f5774006c5d82904db327d2f118d6a5c99",
+      "self_attn.k_norm.weight": "cb20faa93398541fe6b2fbda2a527ea3243337db753acebdfd045bf309cbc4ae",
+      "mlp.gate_proj.weight": "06d454e81788e8cfd28f613250c2c97f44fd78227c38bd35429f19915cdaeb51",
+      "mlp.up_proj.weight": "2c58e52893c9f2de1310538074a6ec2700403d256286f410d59a25064527f6c2",
+      "mlp.down_proj.weight": "d65d2b30d50eb54acafa83fef24d9a0fa7d57b6cb6cc06a94e476c758f8812d6",
+      "input_layernorm.weight": "316472831e20dec19263b56944811a059efb241cc842d8ace4fce706c98a8b11",
+      "post_attention_layernorm.weight": "7a462c4c15d73900fe1275d32448251905112e9530f615fe6776622c416f0f52"
+    },
+    "anchor_after_sha256": {
+      "mlp.gate_proj.weight": "06d454e81788e8cfd28f613250c2c97f44fd78227c38bd35429f19915cdaeb51",
+      "mlp.up_proj.weight": "2c58e52893c9f2de1310538074a6ec2700403d256286f410d59a25064527f6c2",
+      "mlp.down_proj.weight": "d65d2b30d50eb54acafa83fef24d9a0fa7d57b6cb6cc06a94e476c758f8812d6"
+    },
+    "norm_policy": "keep_Wa_including_QK_norms",
+    "source_mutated_by_merge": false,
+    "fisher_computed": false,
+    "fit": false,
+    "optimizer_steps": 0,
+    "backward_calls": 0
+  }
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_07_transport.pt

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

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_08_merge.json

@@ -0,0 +1,110 @@
+{
+  "cycle": 8,
+  "anchor": 12,
+  "removed_original_layer": 20,
+  "selection_policy": "fixed_our_span_13_22_anchor12",
+  "fit": false,
+  "lambda_left": 0.0,
+  "transport_matrix_sha256": "2c7b2775e51300a42d0d75c89a6c22bee3e7c935b89f0db3cf2b3fd9863b8fd6",
+  "transport": {
+    "stats": {
+      "tokens": 65536,
+      "ridge_relative": 0.001,
+      "ridge_absolute": 6.060115993022919e-05,
+      "gram_mean_diagonal": 0.06060115993022919,
+      "calibration_nmse": 0.10606533290714001,
+      "calibration_cosine": 0.9454815765850116,
+      "calibration_norm_ratio": 0.9446186925723196,
+      "transport_relative_identity_distance": 0.5891098976135254,
+      "enabled": true,
+      "batches": 32,
+      "coordinate_fit": "X_anchor @ T ~= X_source",
+      "weight_rewrite": [
+        "mlp.gate_proj.weight <- W_source @ T.T",
+        "mlp.up_proj.weight <- W_source @ T.T"
+      ],
+      "down_proj_transported": false,
+      "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+    },
+    "source_before_sha256": {
+      "self_attn.q_proj.weight": "6bdb1d9174c7bf6d06b12d5d55b3a7649f4f880714e3e2d5a6f90c1449ad1a50",
+      "self_attn.k_proj.weight": "e3a98bfec07bba4f0fc6aa01b510f13fce379d8a5fdce7a70ce0870da65a2e43",
+      "self_attn.v_proj.weight": "f250ec94ab67ea3d397297fa0c70e7e24c7f77ca609a3a83cc8f7e792e4bc608",
+      "self_attn.o_proj.weight": "18f0f0ec64b28cbc88f0937245cb010fd86dcf094de2d96d1bd2162b76020229",
+      "self_attn.q_norm.weight": "2172344fe2c1fda6f261ece920fbd07a4b03d2385d2c0848c497aae4f07e69b5",
+      "self_attn.k_norm.weight": "a2c8f7815e194c45bad87d1e291c9ff2ad3a36929b1201d024354ec501563a4e",
+      "mlp.gate_proj.weight": "8334c424ddf9edb282ccb34d6f90321e9530eff5e81b7881ba9b3d74417a9672",
+      "mlp.up_proj.weight": "db91586fd2907e8ecccb075f036e5c180641fa35f7cd899a3f81411caa9d10df",
+      "mlp.down_proj.weight": "4d5fefc568246a3abfa21725082f7fdf4dd62e7c580a1280aebe0ec60a2230cd",
+      "input_layernorm.weight": "96fb39db2f64c716ae6891acb4e4e7f2a1276921a97d0d9a50d746727e4bbcd0",
+      "post_attention_layernorm.weight": "cd331d158252933122eae174cda361e7f3eb260b867b079b375650b368a4ae06"
+    },
+    "source_after_sha256": {
+      "self_attn.q_proj.weight": "6bdb1d9174c7bf6d06b12d5d55b3a7649f4f880714e3e2d5a6f90c1449ad1a50",
+      "self_attn.k_proj.weight": "e3a98bfec07bba4f0fc6aa01b510f13fce379d8a5fdce7a70ce0870da65a2e43",
+      "self_attn.v_proj.weight": "f250ec94ab67ea3d397297fa0c70e7e24c7f77ca609a3a83cc8f7e792e4bc608",
+      "self_attn.o_proj.weight": "18f0f0ec64b28cbc88f0937245cb010fd86dcf094de2d96d1bd2162b76020229",
+      "self_attn.q_norm.weight": "2172344fe2c1fda6f261ece920fbd07a4b03d2385d2c0848c497aae4f07e69b5",
+      "self_attn.k_norm.weight": "a2c8f7815e194c45bad87d1e291c9ff2ad3a36929b1201d024354ec501563a4e",
+      "mlp.gate_proj.weight": "9f8d001778d2562d9f0deb7aa67ab4b374ee11bc56cf341dd3bbc2f89da978a9",
+      "mlp.up_proj.weight": "82d2d94c9a1082f87643386884771be030ad54381da7fbfda1931d886bff69bc",
+      "mlp.down_proj.weight": "4d5fefc568246a3abfa21725082f7fdf4dd62e7c580a1280aebe0ec60a2230cd",
+      "input_layernorm.weight": "96fb39db2f64c716ae6891acb4e4e7f2a1276921a97d0d9a50d746727e4bbcd0",
+      "post_attention_layernorm.weight": "cd331d158252933122eae174cda361e7f3eb260b867b079b375650b368a4ae06"
+    },
+    "changed": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight"
+    ]
+  },
+  "merge": {
+    "initializer": "wb",
+    "lambda_left": 0.0,
+    "lambda_right": 1.0,
+    "projection_names": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight",
+      "mlp.down_proj.weight"
+    ],
+    "scope": "mlp",
+    "frozen_anchor_sha256": {
+      "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+      "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+      "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+      "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+      "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+      "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+      "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+      "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+    },
+    "anchor_before_sha256": {
+      "mlp.gate_proj.weight": "06d454e81788e8cfd28f613250c2c97f44fd78227c38bd35429f19915cdaeb51",
+      "mlp.up_proj.weight": "2c58e52893c9f2de1310538074a6ec2700403d256286f410d59a25064527f6c2",
+      "mlp.down_proj.weight": "d65d2b30d50eb54acafa83fef24d9a0fa7d57b6cb6cc06a94e476c758f8812d6"
+    },
+    "source_post_transport_sha256": {
+      "self_attn.q_proj.weight": "6bdb1d9174c7bf6d06b12d5d55b3a7649f4f880714e3e2d5a6f90c1449ad1a50",
+      "self_attn.k_proj.weight": "e3a98bfec07bba4f0fc6aa01b510f13fce379d8a5fdce7a70ce0870da65a2e43",
+      "self_attn.v_proj.weight": "f250ec94ab67ea3d397297fa0c70e7e24c7f77ca609a3a83cc8f7e792e4bc608",
+      "self_attn.o_proj.weight": "18f0f0ec64b28cbc88f0937245cb010fd86dcf094de2d96d1bd2162b76020229",
+      "self_attn.q_norm.weight": "2172344fe2c1fda6f261ece920fbd07a4b03d2385d2c0848c497aae4f07e69b5",
+      "self_attn.k_norm.weight": "a2c8f7815e194c45bad87d1e291c9ff2ad3a36929b1201d024354ec501563a4e",
+      "mlp.gate_proj.weight": "9f8d001778d2562d9f0deb7aa67ab4b374ee11bc56cf341dd3bbc2f89da978a9",
+      "mlp.up_proj.weight": "82d2d94c9a1082f87643386884771be030ad54381da7fbfda1931d886bff69bc",
+      "mlp.down_proj.weight": "4d5fefc568246a3abfa21725082f7fdf4dd62e7c580a1280aebe0ec60a2230cd",
+      "input_layernorm.weight": "96fb39db2f64c716ae6891acb4e4e7f2a1276921a97d0d9a50d746727e4bbcd0",
+      "post_attention_layernorm.weight": "cd331d158252933122eae174cda361e7f3eb260b867b079b375650b368a4ae06"
+    },
+    "anchor_after_sha256": {
+      "mlp.gate_proj.weight": "9f8d001778d2562d9f0deb7aa67ab4b374ee11bc56cf341dd3bbc2f89da978a9",
+      "mlp.up_proj.weight": "82d2d94c9a1082f87643386884771be030ad54381da7fbfda1931d886bff69bc",
+      "mlp.down_proj.weight": "4d5fefc568246a3abfa21725082f7fdf4dd62e7c580a1280aebe0ec60a2230cd"
+    },
+    "norm_policy": "keep_Wa_including_QK_norms",
+    "source_mutated_by_merge": false,
+    "fisher_computed": false,
+    "fit": false,
+    "optimizer_steps": 0,
+    "backward_calls": 0
+  }
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_08_transport.pt

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

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_09_merge.json

@@ -0,0 +1,110 @@
+{
+  "cycle": 9,
+  "anchor": 12,
+  "removed_original_layer": 21,
+  "selection_policy": "fixed_our_span_13_22_anchor12",
+  "fit": false,
+  "lambda_left": 0.0,
+  "transport_matrix_sha256": "7ad34658a18ce5ffbab2f8af974892f191e7db80d7b5da8d19e347938544b107",
+  "transport": {
+    "stats": {
+      "tokens": 65536,
+      "ridge_relative": 0.001,
+      "ridge_absolute": 6.060115993022919e-05,
+      "gram_mean_diagonal": 0.06060115993022919,
+      "calibration_nmse": 0.13979247738453124,
+      "calibration_cosine": 0.927474114888108,
+      "calibration_norm_ratio": 0.9266308047370905,
+      "transport_relative_identity_distance": 0.6954833269119263,
+      "enabled": true,
+      "batches": 32,
+      "coordinate_fit": "X_anchor @ T ~= X_source",
+      "weight_rewrite": [
+        "mlp.gate_proj.weight <- W_source @ T.T",
+        "mlp.up_proj.weight <- W_source @ T.T"
+      ],
+      "down_proj_transported": false,
+      "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+    },
+    "source_before_sha256": {
+      "self_attn.q_proj.weight": "1839858bb3153a7d2907bbc4837cab44494ea4f8f73db2dac5a973f1500537c0",
+      "self_attn.k_proj.weight": "34776759a30508b301e6eeb4c03e74afc6e315a0e4005b788772f03267fa6bad",
+      "self_attn.v_proj.weight": "25ed7a7bfff05b2a63a9489ed945f49ed624baa5ffa7f971c263e4d3aade1d04",
+      "self_attn.o_proj.weight": "a8c4e7b3c03654158c39ea33456a291809aee2893e9dde1fa2d530da216b313c",
+      "self_attn.q_norm.weight": "21aa357e3be95df8e0b87310db2cf759d951d8c9a706c9e1bee207de27cbb87f",
+      "self_attn.k_norm.weight": "0dfad6f8b52d3a2c224e7cd2b5c1fe87db29b927a7d7fb4161f231df6df2ac02",
+      "mlp.gate_proj.weight": "4d745750b386ff30e96c0fe5ac21229e0672de87a3c4d30b7a877c333f250622",
+      "mlp.up_proj.weight": "b0b002f9bd65d4a6b4b37b6cf06139deb86a51ebc96fc27b4ebcff016f3e450b",
+      "mlp.down_proj.weight": "279864f62a9b78fa49dde314b363ca78f22fda503fbf8e9f64437ea6644a084a",
+      "input_layernorm.weight": "2974f6d5be715ca00edf542f4e51e5eb5ced2a292277c1974a92f5f6fec44871",
+      "post_attention_layernorm.weight": "a00da323dd47889f5a6238369523374a092cab49267ad69f4716d7b1c3778d5f"
+    },
+    "source_after_sha256": {
+      "self_attn.q_proj.weight": "1839858bb3153a7d2907bbc4837cab44494ea4f8f73db2dac5a973f1500537c0",
+      "self_attn.k_proj.weight": "34776759a30508b301e6eeb4c03e74afc6e315a0e4005b788772f03267fa6bad",
+      "self_attn.v_proj.weight": "25ed7a7bfff05b2a63a9489ed945f49ed624baa5ffa7f971c263e4d3aade1d04",
+      "self_attn.o_proj.weight": "a8c4e7b3c03654158c39ea33456a291809aee2893e9dde1fa2d530da216b313c",
+      "self_attn.q_norm.weight": "21aa357e3be95df8e0b87310db2cf759d951d8c9a706c9e1bee207de27cbb87f",
+      "self_attn.k_norm.weight": "0dfad6f8b52d3a2c224e7cd2b5c1fe87db29b927a7d7fb4161f231df6df2ac02",
+      "mlp.gate_proj.weight": "6b132cf55ede8fb805c51a5b57c84cddd3ac2e84d4d94d13538a0f3eae146ba2",
+      "mlp.up_proj.weight": "d8ae064ab88056091a57a96a007959b9d01bb6c1f037cdab35d76d5f5694b3ae",
+      "mlp.down_proj.weight": "279864f62a9b78fa49dde314b363ca78f22fda503fbf8e9f64437ea6644a084a",
+      "input_layernorm.weight": "2974f6d5be715ca00edf542f4e51e5eb5ced2a292277c1974a92f5f6fec44871",
+      "post_attention_layernorm.weight": "a00da323dd47889f5a6238369523374a092cab49267ad69f4716d7b1c3778d5f"
+    },
+    "changed": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight"
+    ]
+  },
+  "merge": {
+    "initializer": "wb",
+    "lambda_left": 0.0,
+    "lambda_right": 1.0,
+    "projection_names": [
+      "mlp.gate_proj.weight",
+      "mlp.up_proj.weight",
+      "mlp.down_proj.weight"
+    ],
+    "scope": "mlp",
+    "frozen_anchor_sha256": {
+      "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+      "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+      "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+      "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+      "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+      "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+      "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+      "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+    },
+    "anchor_before_sha256": {
+      "mlp.gate_proj.weight": "9f8d001778d2562d9f0deb7aa67ab4b374ee11bc56cf341dd3bbc2f89da978a9",
+      "mlp.up_proj.weight": "82d2d94c9a1082f87643386884771be030ad54381da7fbfda1931d886bff69bc",
+      "mlp.down_proj.weight": "4d5fefc568246a3abfa21725082f7fdf4dd62e7c580a1280aebe0ec60a2230cd"
+    },
+    "source_post_transport_sha256": {
+      "self_attn.q_proj.weight": "1839858bb3153a7d2907bbc4837cab44494ea4f8f73db2dac5a973f1500537c0",
+      "self_attn.k_proj.weight": "34776759a30508b301e6eeb4c03e74afc6e315a0e4005b788772f03267fa6bad",
+      "self_attn.v_proj.weight": "25ed7a7bfff05b2a63a9489ed945f49ed624baa5ffa7f971c263e4d3aade1d04",
+      "self_attn.o_proj.weight": "a8c4e7b3c03654158c39ea33456a291809aee2893e9dde1fa2d530da216b313c",
+      "self_attn.q_norm.weight": "21aa357e3be95df8e0b87310db2cf759d951d8c9a706c9e1bee207de27cbb87f",
+      "self_attn.k_norm.weight": "0dfad6f8b52d3a2c224e7cd2b5c1fe87db29b927a7d7fb4161f231df6df2ac02",
+      "mlp.gate_proj.weight": "6b132cf55ede8fb805c51a5b57c84cddd3ac2e84d4d94d13538a0f3eae146ba2",
+      "mlp.up_proj.weight": "d8ae064ab88056091a57a96a007959b9d01bb6c1f037cdab35d76d5f5694b3ae",
+      "mlp.down_proj.weight": "279864f62a9b78fa49dde314b363ca78f22fda503fbf8e9f64437ea6644a084a",
+      "input_layernorm.weight": "2974f6d5be715ca00edf542f4e51e5eb5ced2a292277c1974a92f5f6fec44871",
+      "post_attention_layernorm.weight": "a00da323dd47889f5a6238369523374a092cab49267ad69f4716d7b1c3778d5f"
+    },
+    "anchor_after_sha256": {
+      "mlp.gate_proj.weight": "6b132cf55ede8fb805c51a5b57c84cddd3ac2e84d4d94d13538a0f3eae146ba2",
+      "mlp.up_proj.weight": "d8ae064ab88056091a57a96a007959b9d01bb6c1f037cdab35d76d5f5694b3ae",
+      "mlp.down_proj.weight": "279864f62a9b78fa49dde314b363ca78f22fda503fbf8e9f64437ea6644a084a"
+    },
+    "norm_policy": "keep_Wa_including_QK_norms",
+    "source_mutated_by_merge": false,
+    "fisher_computed": false,
+    "fit": false,
+    "optimizer_steps": 0,
+    "backward_calls": 0
+  }
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/cycle_09_transport.pt

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

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/data_manifest.json

@@ -0,0 +1,15 @@
+{
+  "model": "Qwen/Qwen3-8B-Base",
+  "model_revision": "49e3418fbbbca6ecbdf9608b4d22e5a407081db4",
+  "dataset": "DKYoon/SlimPajama-6B",
+  "revision": "b5f90f419b7489cdba26fdbc8c022fcb5562f968",
+  "split": "train",
+  "packing": "historical nonstreaming dataset.shuffle(seed42); concatenate encoded text without separators or BOS",
+  "samples": 64,
+  "seq_len": 1024,
+  "batch_size": 2,
+  "seed": 42,
+  "valid_tokens": 65536,
+  "input_ids_sha256": "85a84b9a68cf0856fd363186d3a273860886b1c17f876cae145fd092454aff55",
+  "attention_mask_sha256": "b1476de1907209012e63fa502715fd97db26e595352faa808d8c10433a1472a4"
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/audit/selection.json

@@ -0,0 +1,992 @@
+[
+  {
+    "cycle": 1,
+    "anchor": 12,
+    "removed_original_layer": 13,
+    "selection_policy": "fixed_our_span_13_22_anchor12",
+    "fit": false,
+    "lambda_left": 0.0,
+    "transport_matrix_sha256": "ea43767088fa2f8cc0b7ba197024635f7b8a7e19fdd34170b499f470c2461672",
+    "transport": {
+      "stats": {
+        "tokens": 65536,
+        "ridge_relative": 0.001,
+        "ridge_absolute": 6.060115993022919e-05,
+        "gram_mean_diagonal": 0.06060115993022919,
+        "calibration_nmse": 0.12798181447783583,
+        "calibration_cosine": 0.9338195359584089,
+        "calibration_norm_ratio": 0.9329591782339236,
+        "transport_relative_identity_distance": 0.4961368441581726,
+        "enabled": true,
+        "batches": 32,
+        "coordinate_fit": "X_anchor @ T ~= X_source",
+        "weight_rewrite": [
+          "mlp.gate_proj.weight <- W_source @ T.T",
+          "mlp.up_proj.weight <- W_source @ T.T"
+        ],
+        "down_proj_transported": false,
+        "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+      },
+      "source_before_sha256": {
+        "self_attn.q_proj.weight": "67540e2474547f1d622b738128696574720591fddabb8157d2f6812ecc3af308",
+        "self_attn.k_proj.weight": "efbe8b71b99ef90277849155ebc45e9aad5ffe746f2958c077c7c7130d783c7b",
+        "self_attn.v_proj.weight": "c53545e1ac9a6447efa83242434a0b28bcda5fe12ef3866e173dd13c3da45e38",
+        "self_attn.o_proj.weight": "8812afef76626e47fb5dffe3a77a0cb07a07e8a7f5cf3a97453368a1284b0ffa",
+        "self_attn.q_norm.weight": "79bbb659cb1c2af322ca85abf7d26b088c837bcd284e70efa95a6449f69b5673",
+        "self_attn.k_norm.weight": "e50a57833625792c16439de078eeb810df393e1a49ef7bbe43f5af6a93923adc",
+        "mlp.gate_proj.weight": "6bc0a4412e6639d40e3a7d5c9099a5a05f2573bd12744019550fc11da2c52c55",
+        "mlp.up_proj.weight": "8715dd4fa81b5d58a577a1b2fdfb24592b23775921014b36f832fe8dbf2bbf51",
+        "mlp.down_proj.weight": "032dc5aba56bd954e7498918ca13b8589c12587c97ad88560480e8d28c18883b",
+        "input_layernorm.weight": "c419d161cc4932ecddf0ec98cbe5737b92688f0d5aa71a7e95d2006ca824ffca",
+        "post_attention_layernorm.weight": "ee6a9a96c2b4f35eb0807060229f10bc28080072ed9ecfa0a17e1aaa3cb4df40"
+      },
+      "source_after_sha256": {
+        "self_attn.q_proj.weight": "67540e2474547f1d622b738128696574720591fddabb8157d2f6812ecc3af308",
+        "self_attn.k_proj.weight": "efbe8b71b99ef90277849155ebc45e9aad5ffe746f2958c077c7c7130d783c7b",
+        "self_attn.v_proj.weight": "c53545e1ac9a6447efa83242434a0b28bcda5fe12ef3866e173dd13c3da45e38",
+        "self_attn.o_proj.weight": "8812afef76626e47fb5dffe3a77a0cb07a07e8a7f5cf3a97453368a1284b0ffa",
+        "self_attn.q_norm.weight": "79bbb659cb1c2af322ca85abf7d26b088c837bcd284e70efa95a6449f69b5673",
+        "self_attn.k_norm.weight": "e50a57833625792c16439de078eeb810df393e1a49ef7bbe43f5af6a93923adc",
+        "mlp.gate_proj.weight": "655a66345118a70ec952e549407ec7f19222782a04bf0db39c5ee8372372a2bf",
+        "mlp.up_proj.weight": "cb86cdbce20a724154f50658e0c2cfc3ec3d63e3802388217035698470825d82",
+        "mlp.down_proj.weight": "032dc5aba56bd954e7498918ca13b8589c12587c97ad88560480e8d28c18883b",
+        "input_layernorm.weight": "c419d161cc4932ecddf0ec98cbe5737b92688f0d5aa71a7e95d2006ca824ffca",
+        "post_attention_layernorm.weight": "ee6a9a96c2b4f35eb0807060229f10bc28080072ed9ecfa0a17e1aaa3cb4df40"
+      },
+      "changed": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight"
+      ]
+    },
+    "merge": {
+      "initializer": "wb",
+      "lambda_left": 0.0,
+      "lambda_right": 1.0,
+      "projection_names": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight",
+        "mlp.down_proj.weight"
+      ],
+      "scope": "mlp",
+      "frozen_anchor_sha256": {
+        "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+        "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+        "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+        "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+        "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+        "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+        "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+        "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+      },
+      "anchor_before_sha256": {
+        "mlp.gate_proj.weight": "3e138d6d890dfaeeeb88ae9b8a48c084aea69752230749e87f1586b975880ddd",
+        "mlp.up_proj.weight": "1f3dacc4c4a3af2a55d6273cfc2374077a2eda18cec7cf8237e05c54cc1b8ea5",
+        "mlp.down_proj.weight": "7a34a8a9bcc1a25c928397e3be5c409081b9de0ec283d13425482c0020e6db43"
+      },
+      "source_post_transport_sha256": {
+        "self_attn.q_proj.weight": "67540e2474547f1d622b738128696574720591fddabb8157d2f6812ecc3af308",
+        "self_attn.k_proj.weight": "efbe8b71b99ef90277849155ebc45e9aad5ffe746f2958c077c7c7130d783c7b",
+        "self_attn.v_proj.weight": "c53545e1ac9a6447efa83242434a0b28bcda5fe12ef3866e173dd13c3da45e38",
+        "self_attn.o_proj.weight": "8812afef76626e47fb5dffe3a77a0cb07a07e8a7f5cf3a97453368a1284b0ffa",
+        "self_attn.q_norm.weight": "79bbb659cb1c2af322ca85abf7d26b088c837bcd284e70efa95a6449f69b5673",
+        "self_attn.k_norm.weight": "e50a57833625792c16439de078eeb810df393e1a49ef7bbe43f5af6a93923adc",
+        "mlp.gate_proj.weight": "655a66345118a70ec952e549407ec7f19222782a04bf0db39c5ee8372372a2bf",
+        "mlp.up_proj.weight": "cb86cdbce20a724154f50658e0c2cfc3ec3d63e3802388217035698470825d82",
+        "mlp.down_proj.weight": "032dc5aba56bd954e7498918ca13b8589c12587c97ad88560480e8d28c18883b",
+        "input_layernorm.weight": "c419d161cc4932ecddf0ec98cbe5737b92688f0d5aa71a7e95d2006ca824ffca",
+        "post_attention_layernorm.weight": "ee6a9a96c2b4f35eb0807060229f10bc28080072ed9ecfa0a17e1aaa3cb4df40"
+      },
+      "anchor_after_sha256": {
+        "mlp.gate_proj.weight": "655a66345118a70ec952e549407ec7f19222782a04bf0db39c5ee8372372a2bf",
+        "mlp.up_proj.weight": "cb86cdbce20a724154f50658e0c2cfc3ec3d63e3802388217035698470825d82",
+        "mlp.down_proj.weight": "032dc5aba56bd954e7498918ca13b8589c12587c97ad88560480e8d28c18883b"
+      },
+      "norm_policy": "keep_Wa_including_QK_norms",
+      "source_mutated_by_merge": false,
+      "fisher_computed": false,
+      "fit": false,
+      "optimizer_steps": 0,
+      "backward_calls": 0
+    }
+  },
+  {
+    "cycle": 2,
+    "anchor": 12,
+    "removed_original_layer": 14,
+    "selection_policy": "fixed_our_span_13_22_anchor12",
+    "fit": false,
+    "lambda_left": 0.0,
+    "transport_matrix_sha256": "2f2164ca8bffcf85ff9cfb9506308fa1340559aba7e44bda37d1e050e6e82d36",
+    "transport": {
+      "stats": {
+        "tokens": 65536,
+        "ridge_relative": 0.001,
+        "ridge_absolute": 6.060115993022919e-05,
+        "gram_mean_diagonal": 0.06060115993022919,
+        "calibration_nmse": 0.10099672573787757,
+        "calibration_cosine": 0.9481582440752598,
+        "calibration_norm_ratio": 0.9472741933087646,
+        "transport_relative_identity_distance": 0.45524656772613525,
+        "enabled": true,
+        "batches": 32,
+        "coordinate_fit": "X_anchor @ T ~= X_source",
+        "weight_rewrite": [
+          "mlp.gate_proj.weight <- W_source @ T.T",
+          "mlp.up_proj.weight <- W_source @ T.T"
+        ],
+        "down_proj_transported": false,
+        "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+      },
+      "source_before_sha256": {
+        "self_attn.q_proj.weight": "f57ad388d57bb515af2ac9324d86dc9e19c4cc44bc73879a7b409f9c07597c15",
+        "self_attn.k_proj.weight": "09cba09d72eea6b683087478aeaaf6d321423335a9eb57d47006adbc1f336c63",
+        "self_attn.v_proj.weight": "af4adee7b325a938beb530808104ab27a70afc0d494134b3de1f5ea8ef060773",
+        "self_attn.o_proj.weight": "6888fff18d668ea322341951eb6ab19a3fbbc4cf94b758ed0f8dba411a262d1f",
+        "self_attn.q_norm.weight": "e3e9ec56f12aa5ec410018bbac99e6953ad52f3b8b796d73c5bd0cc6545fb93b",
+        "self_attn.k_norm.weight": "a5bf1576b21d93da019094f1a61912669136a5d9e89e8d2301c88f6bf2def290",
+        "mlp.gate_proj.weight": "1d90e8cf937190e4027f0c7bc34bbabd5bb43c5f3d081537e0d866da8a3efe3f",
+        "mlp.up_proj.weight": "dc867f2d0718d761bb166f69bd21878837006daf9ae392c955a2e9578a15ad97",
+        "mlp.down_proj.weight": "0ac1fc28ab86d85f9cb5f40fbde4485ceac5d2d531a13f5f05d81910ebd8b48d",
+        "input_layernorm.weight": "c21d58d80fa7aca24ff0dac67092f8204b3876926fa095bb7e6ceb3a16060706",
+        "post_attention_layernorm.weight": "1e599b9bd0ed7fdbcef34cff94651bf467bf923745a76a96d33a74ae551ad5d5"
+      },
+      "source_after_sha256": {
+        "self_attn.q_proj.weight": "f57ad388d57bb515af2ac9324d86dc9e19c4cc44bc73879a7b409f9c07597c15",
+        "self_attn.k_proj.weight": "09cba09d72eea6b683087478aeaaf6d321423335a9eb57d47006adbc1f336c63",
+        "self_attn.v_proj.weight": "af4adee7b325a938beb530808104ab27a70afc0d494134b3de1f5ea8ef060773",
+        "self_attn.o_proj.weight": "6888fff18d668ea322341951eb6ab19a3fbbc4cf94b758ed0f8dba411a262d1f",
+        "self_attn.q_norm.weight": "e3e9ec56f12aa5ec410018bbac99e6953ad52f3b8b796d73c5bd0cc6545fb93b",
+        "self_attn.k_norm.weight": "a5bf1576b21d93da019094f1a61912669136a5d9e89e8d2301c88f6bf2def290",
+        "mlp.gate_proj.weight": "f7c92c612a7c8544bac0f0123aff1cb5f922f5b1cf88006c20b8768643f37029",
+        "mlp.up_proj.weight": "4a3522038cb62630906e194bfc0a6e0d5b7f7e8a614b029b83f93145bc4c4a04",
+        "mlp.down_proj.weight": "0ac1fc28ab86d85f9cb5f40fbde4485ceac5d2d531a13f5f05d81910ebd8b48d",
+        "input_layernorm.weight": "c21d58d80fa7aca24ff0dac67092f8204b3876926fa095bb7e6ceb3a16060706",
+        "post_attention_layernorm.weight": "1e599b9bd0ed7fdbcef34cff94651bf467bf923745a76a96d33a74ae551ad5d5"
+      },
+      "changed": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight"
+      ]
+    },
+    "merge": {
+      "initializer": "wb",
+      "lambda_left": 0.0,
+      "lambda_right": 1.0,
+      "projection_names": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight",
+        "mlp.down_proj.weight"
+      ],
+      "scope": "mlp",
+      "frozen_anchor_sha256": {
+        "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+        "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+        "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+        "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+        "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+        "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+        "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+        "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+      },
+      "anchor_before_sha256": {
+        "mlp.gate_proj.weight": "655a66345118a70ec952e549407ec7f19222782a04bf0db39c5ee8372372a2bf",
+        "mlp.up_proj.weight": "cb86cdbce20a724154f50658e0c2cfc3ec3d63e3802388217035698470825d82",
+        "mlp.down_proj.weight": "032dc5aba56bd954e7498918ca13b8589c12587c97ad88560480e8d28c18883b"
+      },
+      "source_post_transport_sha256": {
+        "self_attn.q_proj.weight": "f57ad388d57bb515af2ac9324d86dc9e19c4cc44bc73879a7b409f9c07597c15",
+        "self_attn.k_proj.weight": "09cba09d72eea6b683087478aeaaf6d321423335a9eb57d47006adbc1f336c63",
+        "self_attn.v_proj.weight": "af4adee7b325a938beb530808104ab27a70afc0d494134b3de1f5ea8ef060773",
+        "self_attn.o_proj.weight": "6888fff18d668ea322341951eb6ab19a3fbbc4cf94b758ed0f8dba411a262d1f",
+        "self_attn.q_norm.weight": "e3e9ec56f12aa5ec410018bbac99e6953ad52f3b8b796d73c5bd0cc6545fb93b",
+        "self_attn.k_norm.weight": "a5bf1576b21d93da019094f1a61912669136a5d9e89e8d2301c88f6bf2def290",
+        "mlp.gate_proj.weight": "f7c92c612a7c8544bac0f0123aff1cb5f922f5b1cf88006c20b8768643f37029",
+        "mlp.up_proj.weight": "4a3522038cb62630906e194bfc0a6e0d5b7f7e8a614b029b83f93145bc4c4a04",
+        "mlp.down_proj.weight": "0ac1fc28ab86d85f9cb5f40fbde4485ceac5d2d531a13f5f05d81910ebd8b48d",
+        "input_layernorm.weight": "c21d58d80fa7aca24ff0dac67092f8204b3876926fa095bb7e6ceb3a16060706",
+        "post_attention_layernorm.weight": "1e599b9bd0ed7fdbcef34cff94651bf467bf923745a76a96d33a74ae551ad5d5"
+      },
+      "anchor_after_sha256": {
+        "mlp.gate_proj.weight": "f7c92c612a7c8544bac0f0123aff1cb5f922f5b1cf88006c20b8768643f37029",
+        "mlp.up_proj.weight": "4a3522038cb62630906e194bfc0a6e0d5b7f7e8a614b029b83f93145bc4c4a04",
+        "mlp.down_proj.weight": "0ac1fc28ab86d85f9cb5f40fbde4485ceac5d2d531a13f5f05d81910ebd8b48d"
+      },
+      "norm_policy": "keep_Wa_including_QK_norms",
+      "source_mutated_by_merge": false,
+      "fisher_computed": false,
+      "fit": false,
+      "optimizer_steps": 0,
+      "backward_calls": 0
+    }
+  },
+  {
+    "cycle": 3,
+    "anchor": 12,
+    "removed_original_layer": 15,
+    "selection_policy": "fixed_our_span_13_22_anchor12",
+    "fit": false,
+    "lambda_left": 0.0,
+    "transport_matrix_sha256": "c74bae7cb32fe1396e861248ba6bf41c2fd708fc354660e485db8f232fea727e",
+    "transport": {
+      "stats": {
+        "tokens": 65536,
+        "ridge_relative": 0.001,
+        "ridge_absolute": 6.060115993022919e-05,
+        "gram_mean_diagonal": 0.06060115993022919,
+        "calibration_nmse": 0.11038890826345682,
+        "calibration_cosine": 0.9431923979113933,
+        "calibration_norm_ratio": 0.9422936536202322,
+        "transport_relative_identity_distance": 0.480193167924881,
+        "enabled": true,
+        "batches": 32,
+        "coordinate_fit": "X_anchor @ T ~= X_source",
+        "weight_rewrite": [
+          "mlp.gate_proj.weight <- W_source @ T.T",
+          "mlp.up_proj.weight <- W_source @ T.T"
+        ],
+        "down_proj_transported": false,
+        "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+      },
+      "source_before_sha256": {
+        "self_attn.q_proj.weight": "6005f741b04aefb4b83452f774f7d013b010b6218020e382a98c92a45d8878ac",
+        "self_attn.k_proj.weight": "e4d7d1464c351cfcb69799eb3e3bf63cc597383cbfb0d07263236ba2d8eb3d5b",
+        "self_attn.v_proj.weight": "25063dfdce05fdcb1a48c5d71c3e0107d7a894b7fb6c0f7defa2e768c68ba3d7",
+        "self_attn.o_proj.weight": "e96bf888e3b0629075b2ee05288e147fd875119467d978c2269ecfeb3b0db4eb",
+        "self_attn.q_norm.weight": "d77168c19fe27a0d64a2611360be089b4435adc62444d0e82a986419be1d9b44",
+        "self_attn.k_norm.weight": "2cbb9d53874b3fe1d350a9c9031d64cd138a1dbac549529d07da2927106a10ff",
+        "mlp.gate_proj.weight": "3acdf3c7c3b8dd224f2837ef92c5e72e8bc7963baa021e9ba2a032da6084c86a",
+        "mlp.up_proj.weight": "6a0bdd43c6eab5e133991697799089710e9077591b56bcbde02440054dbfebbc",
+        "mlp.down_proj.weight": "1f66d7843032883982c0b98e73d9193144e181de07f5506b718d1cea3edb23ea",
+        "input_layernorm.weight": "3f2e5d516a4c80f8d93f0221e5ecbc2e7e692f111118c7c629f210ee9d03419d",
+        "post_attention_layernorm.weight": "3a237234fa5182946c09967a08faec9d9060f4bd780bdd6627f6159edebe2f98"
+      },
+      "source_after_sha256": {
+        "self_attn.q_proj.weight": "6005f741b04aefb4b83452f774f7d013b010b6218020e382a98c92a45d8878ac",
+        "self_attn.k_proj.weight": "e4d7d1464c351cfcb69799eb3e3bf63cc597383cbfb0d07263236ba2d8eb3d5b",
+        "self_attn.v_proj.weight": "25063dfdce05fdcb1a48c5d71c3e0107d7a894b7fb6c0f7defa2e768c68ba3d7",
+        "self_attn.o_proj.weight": "e96bf888e3b0629075b2ee05288e147fd875119467d978c2269ecfeb3b0db4eb",
+        "self_attn.q_norm.weight": "d77168c19fe27a0d64a2611360be089b4435adc62444d0e82a986419be1d9b44",
+        "self_attn.k_norm.weight": "2cbb9d53874b3fe1d350a9c9031d64cd138a1dbac549529d07da2927106a10ff",
+        "mlp.gate_proj.weight": "8292c665701ba7b813c028746607fae674b14b68899c1b53243212237e3d7d2c",
+        "mlp.up_proj.weight": "17669eaa9229e48a498c1cc80e87be7605a037083184521ca6ab99b277bfa6d2",
+        "mlp.down_proj.weight": "1f66d7843032883982c0b98e73d9193144e181de07f5506b718d1cea3edb23ea",
+        "input_layernorm.weight": "3f2e5d516a4c80f8d93f0221e5ecbc2e7e692f111118c7c629f210ee9d03419d",
+        "post_attention_layernorm.weight": "3a237234fa5182946c09967a08faec9d9060f4bd780bdd6627f6159edebe2f98"
+      },
+      "changed": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight"
+      ]
+    },
+    "merge": {
+      "initializer": "wb",
+      "lambda_left": 0.0,
+      "lambda_right": 1.0,
+      "projection_names": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight",
+        "mlp.down_proj.weight"
+      ],
+      "scope": "mlp",
+      "frozen_anchor_sha256": {
+        "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+        "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+        "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+        "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+        "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+        "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+        "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+        "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+      },
+      "anchor_before_sha256": {
+        "mlp.gate_proj.weight": "f7c92c612a7c8544bac0f0123aff1cb5f922f5b1cf88006c20b8768643f37029",
+        "mlp.up_proj.weight": "4a3522038cb62630906e194bfc0a6e0d5b7f7e8a614b029b83f93145bc4c4a04",
+        "mlp.down_proj.weight": "0ac1fc28ab86d85f9cb5f40fbde4485ceac5d2d531a13f5f05d81910ebd8b48d"
+      },
+      "source_post_transport_sha256": {
+        "self_attn.q_proj.weight": "6005f741b04aefb4b83452f774f7d013b010b6218020e382a98c92a45d8878ac",
+        "self_attn.k_proj.weight": "e4d7d1464c351cfcb69799eb3e3bf63cc597383cbfb0d07263236ba2d8eb3d5b",
+        "self_attn.v_proj.weight": "25063dfdce05fdcb1a48c5d71c3e0107d7a894b7fb6c0f7defa2e768c68ba3d7",
+        "self_attn.o_proj.weight": "e96bf888e3b0629075b2ee05288e147fd875119467d978c2269ecfeb3b0db4eb",
+        "self_attn.q_norm.weight": "d77168c19fe27a0d64a2611360be089b4435adc62444d0e82a986419be1d9b44",
+        "self_attn.k_norm.weight": "2cbb9d53874b3fe1d350a9c9031d64cd138a1dbac549529d07da2927106a10ff",
+        "mlp.gate_proj.weight": "8292c665701ba7b813c028746607fae674b14b68899c1b53243212237e3d7d2c",
+        "mlp.up_proj.weight": "17669eaa9229e48a498c1cc80e87be7605a037083184521ca6ab99b277bfa6d2",
+        "mlp.down_proj.weight": "1f66d7843032883982c0b98e73d9193144e181de07f5506b718d1cea3edb23ea",
+        "input_layernorm.weight": "3f2e5d516a4c80f8d93f0221e5ecbc2e7e692f111118c7c629f210ee9d03419d",
+        "post_attention_layernorm.weight": "3a237234fa5182946c09967a08faec9d9060f4bd780bdd6627f6159edebe2f98"
+      },
+      "anchor_after_sha256": {
+        "mlp.gate_proj.weight": "8292c665701ba7b813c028746607fae674b14b68899c1b53243212237e3d7d2c",
+        "mlp.up_proj.weight": "17669eaa9229e48a498c1cc80e87be7605a037083184521ca6ab99b277bfa6d2",
+        "mlp.down_proj.weight": "1f66d7843032883982c0b98e73d9193144e181de07f5506b718d1cea3edb23ea"
+      },
+      "norm_policy": "keep_Wa_including_QK_norms",
+      "source_mutated_by_merge": false,
+      "fisher_computed": false,
+      "fit": false,
+      "optimizer_steps": 0,
+      "backward_calls": 0
+    }
+  },
+  {
+    "cycle": 4,
+    "anchor": 12,
+    "removed_original_layer": 16,
+    "selection_policy": "fixed_our_span_13_22_anchor12",
+    "fit": false,
+    "lambda_left": 0.0,
+    "transport_matrix_sha256": "49bbea5f7162f9479174a850b673f69481d7c2e8e01b01c5a110ec706d662fce",
+    "transport": {
+      "stats": {
+        "tokens": 65536,
+        "ridge_relative": 0.001,
+        "ridge_absolute": 6.060115993022919e-05,
+        "gram_mean_diagonal": 0.06060115993022919,
+        "calibration_nmse": 0.09866496995725485,
+        "calibration_cosine": 0.9493870783680597,
+        "calibration_norm_ratio": 0.9484957145281611,
+        "transport_relative_identity_distance": 0.46458062529563904,
+        "enabled": true,
+        "batches": 32,
+        "coordinate_fit": "X_anchor @ T ~= X_source",
+        "weight_rewrite": [
+          "mlp.gate_proj.weight <- W_source @ T.T",
+          "mlp.up_proj.weight <- W_source @ T.T"
+        ],
+        "down_proj_transported": false,
+        "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+      },
+      "source_before_sha256": {
+        "self_attn.q_proj.weight": "a9874967bd53acfd480ed2bd5552fab4e1a06f610af242d411e176c279e0191a",
+        "self_attn.k_proj.weight": "0a285bc594b54a921f698937c566bce629295ff4befcebb203038dd0d97eb3f0",
+        "self_attn.v_proj.weight": "dd8847c5b10e200df29bf79b30321ec7f1d90427ab9b3d273e18a4cbd83e597d",
+        "self_attn.o_proj.weight": "e6afd2a9ba7c9e6f1911d773062b9d37442a01ead339c9aa9255ff20f146b196",
+        "self_attn.q_norm.weight": "48de60cd86dec981224231f275146bc8d17990394835783504bbf5f0e9c5bb1a",
+        "self_attn.k_norm.weight": "d6ef88be0fc007a2bc5e9f1a0a70b7eac493495b5b54b4f72582378340b9bb4d",
+        "mlp.gate_proj.weight": "171beb5701a83f117d0a59a14a78be2936a062c7aa5700ec39efd9c816af96db",
+        "mlp.up_proj.weight": "e04d543903d934aae9062d2034f71ac4d3fb1ac69bd5f31d365f404c764e535e",
+        "mlp.down_proj.weight": "c297d40f8af2ed96c90ff2f616877b4aaeed4bc2918f0e3b56ea769203724ce1",
+        "input_layernorm.weight": "45d58615dedc0906944d998c52fed1d0d139338362abd51fc1b98ae12edec92a",
+        "post_attention_layernorm.weight": "af332049d823017194704880c92765ab0cf4a519c8819753d0539106ea951cef"
+      },
+      "source_after_sha256": {
+        "self_attn.q_proj.weight": "a9874967bd53acfd480ed2bd5552fab4e1a06f610af242d411e176c279e0191a",
+        "self_attn.k_proj.weight": "0a285bc594b54a921f698937c566bce629295ff4befcebb203038dd0d97eb3f0",
+        "self_attn.v_proj.weight": "dd8847c5b10e200df29bf79b30321ec7f1d90427ab9b3d273e18a4cbd83e597d",
+        "self_attn.o_proj.weight": "e6afd2a9ba7c9e6f1911d773062b9d37442a01ead339c9aa9255ff20f146b196",
+        "self_attn.q_norm.weight": "48de60cd86dec981224231f275146bc8d17990394835783504bbf5f0e9c5bb1a",
+        "self_attn.k_norm.weight": "d6ef88be0fc007a2bc5e9f1a0a70b7eac493495b5b54b4f72582378340b9bb4d",
+        "mlp.gate_proj.weight": "debf2f81470433f78676cc9649af3a208c369737428e6fcf4918ef2f14edeb9b",
+        "mlp.up_proj.weight": "5c1a4ef2663bb8509c1736405a121d2cf0105b113be03629fdd9c8ebae51064a",
+        "mlp.down_proj.weight": "c297d40f8af2ed96c90ff2f616877b4aaeed4bc2918f0e3b56ea769203724ce1",
+        "input_layernorm.weight": "45d58615dedc0906944d998c52fed1d0d139338362abd51fc1b98ae12edec92a",
+        "post_attention_layernorm.weight": "af332049d823017194704880c92765ab0cf4a519c8819753d0539106ea951cef"
+      },
+      "changed": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight"
+      ]
+    },
+    "merge": {
+      "initializer": "wb",
+      "lambda_left": 0.0,
+      "lambda_right": 1.0,
+      "projection_names": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight",
+        "mlp.down_proj.weight"
+      ],
+      "scope": "mlp",
+      "frozen_anchor_sha256": {
+        "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+        "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+        "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+        "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+        "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+        "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+        "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+        "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+      },
+      "anchor_before_sha256": {
+        "mlp.gate_proj.weight": "8292c665701ba7b813c028746607fae674b14b68899c1b53243212237e3d7d2c",
+        "mlp.up_proj.weight": "17669eaa9229e48a498c1cc80e87be7605a037083184521ca6ab99b277bfa6d2",
+        "mlp.down_proj.weight": "1f66d7843032883982c0b98e73d9193144e181de07f5506b718d1cea3edb23ea"
+      },
+      "source_post_transport_sha256": {
+        "self_attn.q_proj.weight": "a9874967bd53acfd480ed2bd5552fab4e1a06f610af242d411e176c279e0191a",
+        "self_attn.k_proj.weight": "0a285bc594b54a921f698937c566bce629295ff4befcebb203038dd0d97eb3f0",
+        "self_attn.v_proj.weight": "dd8847c5b10e200df29bf79b30321ec7f1d90427ab9b3d273e18a4cbd83e597d",
+        "self_attn.o_proj.weight": "e6afd2a9ba7c9e6f1911d773062b9d37442a01ead339c9aa9255ff20f146b196",
+        "self_attn.q_norm.weight": "48de60cd86dec981224231f275146bc8d17990394835783504bbf5f0e9c5bb1a",
+        "self_attn.k_norm.weight": "d6ef88be0fc007a2bc5e9f1a0a70b7eac493495b5b54b4f72582378340b9bb4d",
+        "mlp.gate_proj.weight": "debf2f81470433f78676cc9649af3a208c369737428e6fcf4918ef2f14edeb9b",
+        "mlp.up_proj.weight": "5c1a4ef2663bb8509c1736405a121d2cf0105b113be03629fdd9c8ebae51064a",
+        "mlp.down_proj.weight": "c297d40f8af2ed96c90ff2f616877b4aaeed4bc2918f0e3b56ea769203724ce1",
+        "input_layernorm.weight": "45d58615dedc0906944d998c52fed1d0d139338362abd51fc1b98ae12edec92a",
+        "post_attention_layernorm.weight": "af332049d823017194704880c92765ab0cf4a519c8819753d0539106ea951cef"
+      },
+      "anchor_after_sha256": {
+        "mlp.gate_proj.weight": "debf2f81470433f78676cc9649af3a208c369737428e6fcf4918ef2f14edeb9b",
+        "mlp.up_proj.weight": "5c1a4ef2663bb8509c1736405a121d2cf0105b113be03629fdd9c8ebae51064a",
+        "mlp.down_proj.weight": "c297d40f8af2ed96c90ff2f616877b4aaeed4bc2918f0e3b56ea769203724ce1"
+      },
+      "norm_policy": "keep_Wa_including_QK_norms",
+      "source_mutated_by_merge": false,
+      "fisher_computed": false,
+      "fit": false,
+      "optimizer_steps": 0,
+      "backward_calls": 0
+    }
+  },
+  {
+    "cycle": 5,
+    "anchor": 12,
+    "removed_original_layer": 17,
+    "selection_policy": "fixed_our_span_13_22_anchor12",
+    "fit": false,
+    "lambda_left": 0.0,
+    "transport_matrix_sha256": "b968cc0681a32eab25ab339122b95bf8f1b90e3ced55b7638652d052fbcdbcc3",
+    "transport": {
+      "stats": {
+        "tokens": 65536,
+        "ridge_relative": 0.001,
+        "ridge_absolute": 6.060115993022919e-05,
+        "gram_mean_diagonal": 0.06060115993022919,
+        "calibration_nmse": 0.09917833468174767,
+        "calibration_cosine": 0.9491166565617855,
+        "calibration_norm_ratio": 0.9482434757273703,
+        "transport_relative_identity_distance": 0.4882379472255707,
+        "enabled": true,
+        "batches": 32,
+        "coordinate_fit": "X_anchor @ T ~= X_source",
+        "weight_rewrite": [
+          "mlp.gate_proj.weight <- W_source @ T.T",
+          "mlp.up_proj.weight <- W_source @ T.T"
+        ],
+        "down_proj_transported": false,
+        "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+      },
+      "source_before_sha256": {
+        "self_attn.q_proj.weight": "93af1649dbcf27dcc906cff079a1448af3e0b78dc0ae7fcd0038e95d05f79fdc",
+        "self_attn.k_proj.weight": "919f1a2454b2957fa1f611232b1c0aaccdab718aed512b435923cf972cd52015",
+        "self_attn.v_proj.weight": "2a660e851663561147921fae640f303f3f599da61afc8d68545fed320cc9b63d",
+        "self_attn.o_proj.weight": "bfb11d528abdacfc054070ed7a55f90ddde74fb17704bc742ceffa065adcc717",
+        "self_attn.q_norm.weight": "a4538fa22891825dbfbac330127ff29569ac04b5ab0ee89e60db7e7bc64f26a3",
+        "self_attn.k_norm.weight": "f26654e4f51003513e7ff0cd2f23e99387481dc5c639b01444903ec9632ae685",
+        "mlp.gate_proj.weight": "1ec134d886ea6246b31de9cb6cbb4c451fddfb333fca1e90375f8659eb27d81c",
+        "mlp.up_proj.weight": "b7549bcdd3b5089f09aebb1847587e2049463294f52f4335b88b7e64888edd45",
+        "mlp.down_proj.weight": "2b6fe52a74f5b15de22764a2c9b51acdfc75070dac110580366d2dcd9d207e0f",
+        "input_layernorm.weight": "70025e492885453112e0108ebf4311dfd994db35383e90da14292277834fb949",
+        "post_attention_layernorm.weight": "41357e377104509608d219bc3f4d8a51dde14749a9a6e6b592f6d4f4594faa85"
+      },
+      "source_after_sha256": {
+        "self_attn.q_proj.weight": "93af1649dbcf27dcc906cff079a1448af3e0b78dc0ae7fcd0038e95d05f79fdc",
+        "self_attn.k_proj.weight": "919f1a2454b2957fa1f611232b1c0aaccdab718aed512b435923cf972cd52015",
+        "self_attn.v_proj.weight": "2a660e851663561147921fae640f303f3f599da61afc8d68545fed320cc9b63d",
+        "self_attn.o_proj.weight": "bfb11d528abdacfc054070ed7a55f90ddde74fb17704bc742ceffa065adcc717",
+        "self_attn.q_norm.weight": "a4538fa22891825dbfbac330127ff29569ac04b5ab0ee89e60db7e7bc64f26a3",
+        "self_attn.k_norm.weight": "f26654e4f51003513e7ff0cd2f23e99387481dc5c639b01444903ec9632ae685",
+        "mlp.gate_proj.weight": "98ca3a1f76218aabde9d2dfeb23e28d798f812a336974e190ebaea9076ad4554",
+        "mlp.up_proj.weight": "91405003b4d46ce3a325e27da1f747b7b268d7570d3f6dab4f714a73aae768e6",
+        "mlp.down_proj.weight": "2b6fe52a74f5b15de22764a2c9b51acdfc75070dac110580366d2dcd9d207e0f",
+        "input_layernorm.weight": "70025e492885453112e0108ebf4311dfd994db35383e90da14292277834fb949",
+        "post_attention_layernorm.weight": "41357e377104509608d219bc3f4d8a51dde14749a9a6e6b592f6d4f4594faa85"
+      },
+      "changed": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight"
+      ]
+    },
+    "merge": {
+      "initializer": "wb",
+      "lambda_left": 0.0,
+      "lambda_right": 1.0,
+      "projection_names": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight",
+        "mlp.down_proj.weight"
+      ],
+      "scope": "mlp",
+      "frozen_anchor_sha256": {
+        "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+        "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+        "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+        "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+        "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+        "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+        "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+        "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+      },
+      "anchor_before_sha256": {
+        "mlp.gate_proj.weight": "debf2f81470433f78676cc9649af3a208c369737428e6fcf4918ef2f14edeb9b",
+        "mlp.up_proj.weight": "5c1a4ef2663bb8509c1736405a121d2cf0105b113be03629fdd9c8ebae51064a",
+        "mlp.down_proj.weight": "c297d40f8af2ed96c90ff2f616877b4aaeed4bc2918f0e3b56ea769203724ce1"
+      },
+      "source_post_transport_sha256": {
+        "self_attn.q_proj.weight": "93af1649dbcf27dcc906cff079a1448af3e0b78dc0ae7fcd0038e95d05f79fdc",
+        "self_attn.k_proj.weight": "919f1a2454b2957fa1f611232b1c0aaccdab718aed512b435923cf972cd52015",
+        "self_attn.v_proj.weight": "2a660e851663561147921fae640f303f3f599da61afc8d68545fed320cc9b63d",
+        "self_attn.o_proj.weight": "bfb11d528abdacfc054070ed7a55f90ddde74fb17704bc742ceffa065adcc717",
+        "self_attn.q_norm.weight": "a4538fa22891825dbfbac330127ff29569ac04b5ab0ee89e60db7e7bc64f26a3",
+        "self_attn.k_norm.weight": "f26654e4f51003513e7ff0cd2f23e99387481dc5c639b01444903ec9632ae685",
+        "mlp.gate_proj.weight": "98ca3a1f76218aabde9d2dfeb23e28d798f812a336974e190ebaea9076ad4554",
+        "mlp.up_proj.weight": "91405003b4d46ce3a325e27da1f747b7b268d7570d3f6dab4f714a73aae768e6",
+        "mlp.down_proj.weight": "2b6fe52a74f5b15de22764a2c9b51acdfc75070dac110580366d2dcd9d207e0f",
+        "input_layernorm.weight": "70025e492885453112e0108ebf4311dfd994db35383e90da14292277834fb949",
+        "post_attention_layernorm.weight": "41357e377104509608d219bc3f4d8a51dde14749a9a6e6b592f6d4f4594faa85"
+      },
+      "anchor_after_sha256": {
+        "mlp.gate_proj.weight": "98ca3a1f76218aabde9d2dfeb23e28d798f812a336974e190ebaea9076ad4554",
+        "mlp.up_proj.weight": "91405003b4d46ce3a325e27da1f747b7b268d7570d3f6dab4f714a73aae768e6",
+        "mlp.down_proj.weight": "2b6fe52a74f5b15de22764a2c9b51acdfc75070dac110580366d2dcd9d207e0f"
+      },
+      "norm_policy": "keep_Wa_including_QK_norms",
+      "source_mutated_by_merge": false,
+      "fisher_computed": false,
+      "fit": false,
+      "optimizer_steps": 0,
+      "backward_calls": 0
+    }
+  },
+  {
+    "cycle": 6,
+    "anchor": 12,
+    "removed_original_layer": 18,
+    "selection_policy": "fixed_our_span_13_22_anchor12",
+    "fit": false,
+    "lambda_left": 0.0,
+    "transport_matrix_sha256": "b1c313ea0a3aa1df29a0618ae2ef9e5bc49705d8fb26ca876cad9c127db74e9e",
+    "transport": {
+      "stats": {
+        "tokens": 65536,
+        "ridge_relative": 0.001,
+        "ridge_absolute": 6.060115993022919e-05,
+        "gram_mean_diagonal": 0.06060115993022919,
+        "calibration_nmse": 0.09820423130187533,
+        "calibration_cosine": 0.9496297005441647,
+        "calibration_norm_ratio": 0.9487355766850942,
+        "transport_relative_identity_distance": 0.48003679513931274,
+        "enabled": true,
+        "batches": 32,
+        "coordinate_fit": "X_anchor @ T ~= X_source",
+        "weight_rewrite": [
+          "mlp.gate_proj.weight <- W_source @ T.T",
+          "mlp.up_proj.weight <- W_source @ T.T"
+        ],
+        "down_proj_transported": false,
+        "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+      },
+      "source_before_sha256": {
+        "self_attn.q_proj.weight": "3d50a07d21693613e0d831209868828215164c78606ad76bb5339d0093e2b167",
+        "self_attn.k_proj.weight": "055922b3d6d8ae628f8a4761be8273b2b35bd979a899e599e03a4aebc9b31b15",
+        "self_attn.v_proj.weight": "35d50fc9ef07106a763c826a6bed55f5f8de393edeac002703ab161116d8dead",
+        "self_attn.o_proj.weight": "a211c679b699b735e0587b7e0bab5610d182a4c54868438be766544a8f36b4eb",
+        "self_attn.q_norm.weight": "41ed057917753085abc49146d705c39743047800a2ac65dba3e227fb675ad494",
+        "self_attn.k_norm.weight": "f01c939b42b6e7b3a03519eadb0a08a563897458717fc05d98b7c7d158621f02",
+        "mlp.gate_proj.weight": "a60ac64753890f45bc06d840148fad55807f022c4f14d6437d926bfe08d6e401",
+        "mlp.up_proj.weight": "f614342e9f77c5b73e0b93c34e9a6cbfb1692decfd132853765e9da75c5a2edc",
+        "mlp.down_proj.weight": "b61bbddd0e5ee13e6679fb129a28885d063105955f6cb5176c39b0ac18fbfda7",
+        "input_layernorm.weight": "2c7f7059994a701ae1bfd696bd109340fa7a22df9deee3bfd6c4afb890155523",
+        "post_attention_layernorm.weight": "d85cdb5cf77b8d6d42c74fbd6aff643661b72fcfbe4f343311c4d31db4afc67f"
+      },
+      "source_after_sha256": {
+        "self_attn.q_proj.weight": "3d50a07d21693613e0d831209868828215164c78606ad76bb5339d0093e2b167",
+        "self_attn.k_proj.weight": "055922b3d6d8ae628f8a4761be8273b2b35bd979a899e599e03a4aebc9b31b15",
+        "self_attn.v_proj.weight": "35d50fc9ef07106a763c826a6bed55f5f8de393edeac002703ab161116d8dead",
+        "self_attn.o_proj.weight": "a211c679b699b735e0587b7e0bab5610d182a4c54868438be766544a8f36b4eb",
+        "self_attn.q_norm.weight": "41ed057917753085abc49146d705c39743047800a2ac65dba3e227fb675ad494",
+        "self_attn.k_norm.weight": "f01c939b42b6e7b3a03519eadb0a08a563897458717fc05d98b7c7d158621f02",
+        "mlp.gate_proj.weight": "03eb425fe1ff0c465accdbd062fa76ec3b951f4c173d9f900657e922811eff2f",
+        "mlp.up_proj.weight": "f482573a958623f2511b60e6bfdb8ddf1b18a35942833a3cf2f6036131673c06",
+        "mlp.down_proj.weight": "b61bbddd0e5ee13e6679fb129a28885d063105955f6cb5176c39b0ac18fbfda7",
+        "input_layernorm.weight": "2c7f7059994a701ae1bfd696bd109340fa7a22df9deee3bfd6c4afb890155523",
+        "post_attention_layernorm.weight": "d85cdb5cf77b8d6d42c74fbd6aff643661b72fcfbe4f343311c4d31db4afc67f"
+      },
+      "changed": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight"
+      ]
+    },
+    "merge": {
+      "initializer": "wb",
+      "lambda_left": 0.0,
+      "lambda_right": 1.0,
+      "projection_names": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight",
+        "mlp.down_proj.weight"
+      ],
+      "scope": "mlp",
+      "frozen_anchor_sha256": {
+        "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+        "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+        "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+        "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+        "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+        "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+        "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+        "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+      },
+      "anchor_before_sha256": {
+        "mlp.gate_proj.weight": "98ca3a1f76218aabde9d2dfeb23e28d798f812a336974e190ebaea9076ad4554",
+        "mlp.up_proj.weight": "91405003b4d46ce3a325e27da1f747b7b268d7570d3f6dab4f714a73aae768e6",
+        "mlp.down_proj.weight": "2b6fe52a74f5b15de22764a2c9b51acdfc75070dac110580366d2dcd9d207e0f"
+      },
+      "source_post_transport_sha256": {
+        "self_attn.q_proj.weight": "3d50a07d21693613e0d831209868828215164c78606ad76bb5339d0093e2b167",
+        "self_attn.k_proj.weight": "055922b3d6d8ae628f8a4761be8273b2b35bd979a899e599e03a4aebc9b31b15",
+        "self_attn.v_proj.weight": "35d50fc9ef07106a763c826a6bed55f5f8de393edeac002703ab161116d8dead",
+        "self_attn.o_proj.weight": "a211c679b699b735e0587b7e0bab5610d182a4c54868438be766544a8f36b4eb",
+        "self_attn.q_norm.weight": "41ed057917753085abc49146d705c39743047800a2ac65dba3e227fb675ad494",
+        "self_attn.k_norm.weight": "f01c939b42b6e7b3a03519eadb0a08a563897458717fc05d98b7c7d158621f02",
+        "mlp.gate_proj.weight": "03eb425fe1ff0c465accdbd062fa76ec3b951f4c173d9f900657e922811eff2f",
+        "mlp.up_proj.weight": "f482573a958623f2511b60e6bfdb8ddf1b18a35942833a3cf2f6036131673c06",
+        "mlp.down_proj.weight": "b61bbddd0e5ee13e6679fb129a28885d063105955f6cb5176c39b0ac18fbfda7",
+        "input_layernorm.weight": "2c7f7059994a701ae1bfd696bd109340fa7a22df9deee3bfd6c4afb890155523",
+        "post_attention_layernorm.weight": "d85cdb5cf77b8d6d42c74fbd6aff643661b72fcfbe4f343311c4d31db4afc67f"
+      },
+      "anchor_after_sha256": {
+        "mlp.gate_proj.weight": "03eb425fe1ff0c465accdbd062fa76ec3b951f4c173d9f900657e922811eff2f",
+        "mlp.up_proj.weight": "f482573a958623f2511b60e6bfdb8ddf1b18a35942833a3cf2f6036131673c06",
+        "mlp.down_proj.weight": "b61bbddd0e5ee13e6679fb129a28885d063105955f6cb5176c39b0ac18fbfda7"
+      },
+      "norm_policy": "keep_Wa_including_QK_norms",
+      "source_mutated_by_merge": false,
+      "fisher_computed": false,
+      "fit": false,
+      "optimizer_steps": 0,
+      "backward_calls": 0
+    }
+  },
+  {
+    "cycle": 7,
+    "anchor": 12,
+    "removed_original_layer": 19,
+    "selection_policy": "fixed_our_span_13_22_anchor12",
+    "fit": false,
+    "lambda_left": 0.0,
+    "transport_matrix_sha256": "4b807a71a3f5c920f7bbe9842c8bc0c89de7ebf5b02893847374cb46eeebbaae",
+    "transport": {
+      "stats": {
+        "tokens": 65536,
+        "ridge_relative": 0.001,
+        "ridge_absolute": 6.060115993022919e-05,
+        "gram_mean_diagonal": 0.06060115993022919,
+        "calibration_nmse": 0.103606409701293,
+        "calibration_cosine": 0.9467810247760247,
+        "calibration_norm_ratio": 0.9459333354270779,
+        "transport_relative_identity_distance": 0.5275545120239258,
+        "enabled": true,
+        "batches": 32,
+        "coordinate_fit": "X_anchor @ T ~= X_source",
+        "weight_rewrite": [
+          "mlp.gate_proj.weight <- W_source @ T.T",
+          "mlp.up_proj.weight <- W_source @ T.T"
+        ],
+        "down_proj_transported": false,
+        "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+      },
+      "source_before_sha256": {
+        "self_attn.q_proj.weight": "d14bc25171528405c3db791fd017b4e0fe37d06a9b07a9878cb81c1f0eb98ae6",
+        "self_attn.k_proj.weight": "8911d7363eb8d7e35ff407ac925183a06d54d624a8d2bd0ff41db97423515a54",
+        "self_attn.v_proj.weight": "4781046a7d6224a77c3e34dda92a2ef5748eb777d9d554acf5621c4e5742be2a",
+        "self_attn.o_proj.weight": "90f47fc1bc507ddfad16299dfcecb78a6b4efac01e21d3a6402c6ef3eae56348",
+        "self_attn.q_norm.weight": "6915d87fcc2402518b382dee5f5929f5774006c5d82904db327d2f118d6a5c99",
+        "self_attn.k_norm.weight": "cb20faa93398541fe6b2fbda2a527ea3243337db753acebdfd045bf309cbc4ae",
+        "mlp.gate_proj.weight": "aaf6792caf14dc5a810bfa937c966c7989238e23b21080752c784428eedbf79c",
+        "mlp.up_proj.weight": "5a9cf857484fc35820ab3032e13383687631e54fc1a7c7ff0443ec36e962cf17",
+        "mlp.down_proj.weight": "d65d2b30d50eb54acafa83fef24d9a0fa7d57b6cb6cc06a94e476c758f8812d6",
+        "input_layernorm.weight": "316472831e20dec19263b56944811a059efb241cc842d8ace4fce706c98a8b11",
+        "post_attention_layernorm.weight": "7a462c4c15d73900fe1275d32448251905112e9530f615fe6776622c416f0f52"
+      },
+      "source_after_sha256": {
+        "self_attn.q_proj.weight": "d14bc25171528405c3db791fd017b4e0fe37d06a9b07a9878cb81c1f0eb98ae6",
+        "self_attn.k_proj.weight": "8911d7363eb8d7e35ff407ac925183a06d54d624a8d2bd0ff41db97423515a54",
+        "self_attn.v_proj.weight": "4781046a7d6224a77c3e34dda92a2ef5748eb777d9d554acf5621c4e5742be2a",
+        "self_attn.o_proj.weight": "90f47fc1bc507ddfad16299dfcecb78a6b4efac01e21d3a6402c6ef3eae56348",
+        "self_attn.q_norm.weight": "6915d87fcc2402518b382dee5f5929f5774006c5d82904db327d2f118d6a5c99",
+        "self_attn.k_norm.weight": "cb20faa93398541fe6b2fbda2a527ea3243337db753acebdfd045bf309cbc4ae",
+        "mlp.gate_proj.weight": "06d454e81788e8cfd28f613250c2c97f44fd78227c38bd35429f19915cdaeb51",
+        "mlp.up_proj.weight": "2c58e52893c9f2de1310538074a6ec2700403d256286f410d59a25064527f6c2",
+        "mlp.down_proj.weight": "d65d2b30d50eb54acafa83fef24d9a0fa7d57b6cb6cc06a94e476c758f8812d6",
+        "input_layernorm.weight": "316472831e20dec19263b56944811a059efb241cc842d8ace4fce706c98a8b11",
+        "post_attention_layernorm.weight": "7a462c4c15d73900fe1275d32448251905112e9530f615fe6776622c416f0f52"
+      },
+      "changed": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight"
+      ]
+    },
+    "merge": {
+      "initializer": "wb",
+      "lambda_left": 0.0,
+      "lambda_right": 1.0,
+      "projection_names": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight",
+        "mlp.down_proj.weight"
+      ],
+      "scope": "mlp",
+      "frozen_anchor_sha256": {
+        "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+        "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+        "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+        "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+        "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+        "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+        "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+        "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+      },
+      "anchor_before_sha256": {
+        "mlp.gate_proj.weight": "03eb425fe1ff0c465accdbd062fa76ec3b951f4c173d9f900657e922811eff2f",
+        "mlp.up_proj.weight": "f482573a958623f2511b60e6bfdb8ddf1b18a35942833a3cf2f6036131673c06",
+        "mlp.down_proj.weight": "b61bbddd0e5ee13e6679fb129a28885d063105955f6cb5176c39b0ac18fbfda7"
+      },
+      "source_post_transport_sha256": {
+        "self_attn.q_proj.weight": "d14bc25171528405c3db791fd017b4e0fe37d06a9b07a9878cb81c1f0eb98ae6",
+        "self_attn.k_proj.weight": "8911d7363eb8d7e35ff407ac925183a06d54d624a8d2bd0ff41db97423515a54",
+        "self_attn.v_proj.weight": "4781046a7d6224a77c3e34dda92a2ef5748eb777d9d554acf5621c4e5742be2a",
+        "self_attn.o_proj.weight": "90f47fc1bc507ddfad16299dfcecb78a6b4efac01e21d3a6402c6ef3eae56348",
+        "self_attn.q_norm.weight": "6915d87fcc2402518b382dee5f5929f5774006c5d82904db327d2f118d6a5c99",
+        "self_attn.k_norm.weight": "cb20faa93398541fe6b2fbda2a527ea3243337db753acebdfd045bf309cbc4ae",
+        "mlp.gate_proj.weight": "06d454e81788e8cfd28f613250c2c97f44fd78227c38bd35429f19915cdaeb51",
+        "mlp.up_proj.weight": "2c58e52893c9f2de1310538074a6ec2700403d256286f410d59a25064527f6c2",
+        "mlp.down_proj.weight": "d65d2b30d50eb54acafa83fef24d9a0fa7d57b6cb6cc06a94e476c758f8812d6",
+        "input_layernorm.weight": "316472831e20dec19263b56944811a059efb241cc842d8ace4fce706c98a8b11",
+        "post_attention_layernorm.weight": "7a462c4c15d73900fe1275d32448251905112e9530f615fe6776622c416f0f52"
+      },
+      "anchor_after_sha256": {
+        "mlp.gate_proj.weight": "06d454e81788e8cfd28f613250c2c97f44fd78227c38bd35429f19915cdaeb51",
+        "mlp.up_proj.weight": "2c58e52893c9f2de1310538074a6ec2700403d256286f410d59a25064527f6c2",
+        "mlp.down_proj.weight": "d65d2b30d50eb54acafa83fef24d9a0fa7d57b6cb6cc06a94e476c758f8812d6"
+      },
+      "norm_policy": "keep_Wa_including_QK_norms",
+      "source_mutated_by_merge": false,
+      "fisher_computed": false,
+      "fit": false,
+      "optimizer_steps": 0,
+      "backward_calls": 0
+    }
+  },
+  {
+    "cycle": 8,
+    "anchor": 12,
+    "removed_original_layer": 20,
+    "selection_policy": "fixed_our_span_13_22_anchor12",
+    "fit": false,
+    "lambda_left": 0.0,
+    "transport_matrix_sha256": "2c7b2775e51300a42d0d75c89a6c22bee3e7c935b89f0db3cf2b3fd9863b8fd6",
+    "transport": {
+      "stats": {
+        "tokens": 65536,
+        "ridge_relative": 0.001,
+        "ridge_absolute": 6.060115993022919e-05,
+        "gram_mean_diagonal": 0.06060115993022919,
+        "calibration_nmse": 0.10606533290714001,
+        "calibration_cosine": 0.9454815765850116,
+        "calibration_norm_ratio": 0.9446186925723196,
+        "transport_relative_identity_distance": 0.5891098976135254,
+        "enabled": true,
+        "batches": 32,
+        "coordinate_fit": "X_anchor @ T ~= X_source",
+        "weight_rewrite": [
+          "mlp.gate_proj.weight <- W_source @ T.T",
+          "mlp.up_proj.weight <- W_source @ T.T"
+        ],
+        "down_proj_transported": false,
+        "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+      },
+      "source_before_sha256": {
+        "self_attn.q_proj.weight": "6bdb1d9174c7bf6d06b12d5d55b3a7649f4f880714e3e2d5a6f90c1449ad1a50",
+        "self_attn.k_proj.weight": "e3a98bfec07bba4f0fc6aa01b510f13fce379d8a5fdce7a70ce0870da65a2e43",
+        "self_attn.v_proj.weight": "f250ec94ab67ea3d397297fa0c70e7e24c7f77ca609a3a83cc8f7e792e4bc608",
+        "self_attn.o_proj.weight": "18f0f0ec64b28cbc88f0937245cb010fd86dcf094de2d96d1bd2162b76020229",
+        "self_attn.q_norm.weight": "2172344fe2c1fda6f261ece920fbd07a4b03d2385d2c0848c497aae4f07e69b5",
+        "self_attn.k_norm.weight": "a2c8f7815e194c45bad87d1e291c9ff2ad3a36929b1201d024354ec501563a4e",
+        "mlp.gate_proj.weight": "8334c424ddf9edb282ccb34d6f90321e9530eff5e81b7881ba9b3d74417a9672",
+        "mlp.up_proj.weight": "db91586fd2907e8ecccb075f036e5c180641fa35f7cd899a3f81411caa9d10df",
+        "mlp.down_proj.weight": "4d5fefc568246a3abfa21725082f7fdf4dd62e7c580a1280aebe0ec60a2230cd",
+        "input_layernorm.weight": "96fb39db2f64c716ae6891acb4e4e7f2a1276921a97d0d9a50d746727e4bbcd0",
+        "post_attention_layernorm.weight": "cd331d158252933122eae174cda361e7f3eb260b867b079b375650b368a4ae06"
+      },
+      "source_after_sha256": {
+        "self_attn.q_proj.weight": "6bdb1d9174c7bf6d06b12d5d55b3a7649f4f880714e3e2d5a6f90c1449ad1a50",
+        "self_attn.k_proj.weight": "e3a98bfec07bba4f0fc6aa01b510f13fce379d8a5fdce7a70ce0870da65a2e43",
+        "self_attn.v_proj.weight": "f250ec94ab67ea3d397297fa0c70e7e24c7f77ca609a3a83cc8f7e792e4bc608",
+        "self_attn.o_proj.weight": "18f0f0ec64b28cbc88f0937245cb010fd86dcf094de2d96d1bd2162b76020229",
+        "self_attn.q_norm.weight": "2172344fe2c1fda6f261ece920fbd07a4b03d2385d2c0848c497aae4f07e69b5",
+        "self_attn.k_norm.weight": "a2c8f7815e194c45bad87d1e291c9ff2ad3a36929b1201d024354ec501563a4e",
+        "mlp.gate_proj.weight": "9f8d001778d2562d9f0deb7aa67ab4b374ee11bc56cf341dd3bbc2f89da978a9",
+        "mlp.up_proj.weight": "82d2d94c9a1082f87643386884771be030ad54381da7fbfda1931d886bff69bc",
+        "mlp.down_proj.weight": "4d5fefc568246a3abfa21725082f7fdf4dd62e7c580a1280aebe0ec60a2230cd",
+        "input_layernorm.weight": "96fb39db2f64c716ae6891acb4e4e7f2a1276921a97d0d9a50d746727e4bbcd0",
+        "post_attention_layernorm.weight": "cd331d158252933122eae174cda361e7f3eb260b867b079b375650b368a4ae06"
+      },
+      "changed": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight"
+      ]
+    },
+    "merge": {
+      "initializer": "wb",
+      "lambda_left": 0.0,
+      "lambda_right": 1.0,
+      "projection_names": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight",
+        "mlp.down_proj.weight"
+      ],
+      "scope": "mlp",
+      "frozen_anchor_sha256": {
+        "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+        "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+        "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+        "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+        "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+        "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+        "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+        "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+      },
+      "anchor_before_sha256": {
+        "mlp.gate_proj.weight": "06d454e81788e8cfd28f613250c2c97f44fd78227c38bd35429f19915cdaeb51",
+        "mlp.up_proj.weight": "2c58e52893c9f2de1310538074a6ec2700403d256286f410d59a25064527f6c2",
+        "mlp.down_proj.weight": "d65d2b30d50eb54acafa83fef24d9a0fa7d57b6cb6cc06a94e476c758f8812d6"
+      },
+      "source_post_transport_sha256": {
+        "self_attn.q_proj.weight": "6bdb1d9174c7bf6d06b12d5d55b3a7649f4f880714e3e2d5a6f90c1449ad1a50",
+        "self_attn.k_proj.weight": "e3a98bfec07bba4f0fc6aa01b510f13fce379d8a5fdce7a70ce0870da65a2e43",
+        "self_attn.v_proj.weight": "f250ec94ab67ea3d397297fa0c70e7e24c7f77ca609a3a83cc8f7e792e4bc608",
+        "self_attn.o_proj.weight": "18f0f0ec64b28cbc88f0937245cb010fd86dcf094de2d96d1bd2162b76020229",
+        "self_attn.q_norm.weight": "2172344fe2c1fda6f261ece920fbd07a4b03d2385d2c0848c497aae4f07e69b5",
+        "self_attn.k_norm.weight": "a2c8f7815e194c45bad87d1e291c9ff2ad3a36929b1201d024354ec501563a4e",
+        "mlp.gate_proj.weight": "9f8d001778d2562d9f0deb7aa67ab4b374ee11bc56cf341dd3bbc2f89da978a9",
+        "mlp.up_proj.weight": "82d2d94c9a1082f87643386884771be030ad54381da7fbfda1931d886bff69bc",
+        "mlp.down_proj.weight": "4d5fefc568246a3abfa21725082f7fdf4dd62e7c580a1280aebe0ec60a2230cd",
+        "input_layernorm.weight": "96fb39db2f64c716ae6891acb4e4e7f2a1276921a97d0d9a50d746727e4bbcd0",
+        "post_attention_layernorm.weight": "cd331d158252933122eae174cda361e7f3eb260b867b079b375650b368a4ae06"
+      },
+      "anchor_after_sha256": {
+        "mlp.gate_proj.weight": "9f8d001778d2562d9f0deb7aa67ab4b374ee11bc56cf341dd3bbc2f89da978a9",
+        "mlp.up_proj.weight": "82d2d94c9a1082f87643386884771be030ad54381da7fbfda1931d886bff69bc",
+        "mlp.down_proj.weight": "4d5fefc568246a3abfa21725082f7fdf4dd62e7c580a1280aebe0ec60a2230cd"
+      },
+      "norm_policy": "keep_Wa_including_QK_norms",
+      "source_mutated_by_merge": false,
+      "fisher_computed": false,
+      "fit": false,
+      "optimizer_steps": 0,
+      "backward_calls": 0
+    }
+  },
+  {
+    "cycle": 9,
+    "anchor": 12,
+    "removed_original_layer": 21,
+    "selection_policy": "fixed_our_span_13_22_anchor12",
+    "fit": false,
+    "lambda_left": 0.0,
+    "transport_matrix_sha256": "7ad34658a18ce5ffbab2f8af974892f191e7db80d7b5da8d19e347938544b107",
+    "transport": {
+      "stats": {
+        "tokens": 65536,
+        "ridge_relative": 0.001,
+        "ridge_absolute": 6.060115993022919e-05,
+        "gram_mean_diagonal": 0.06060115993022919,
+        "calibration_nmse": 0.13979247738453124,
+        "calibration_cosine": 0.927474114888108,
+        "calibration_norm_ratio": 0.9266308047370905,
+        "transport_relative_identity_distance": 0.6954833269119263,
+        "enabled": true,
+        "batches": 32,
+        "coordinate_fit": "X_anchor @ T ~= X_source",
+        "weight_rewrite": [
+          "mlp.gate_proj.weight <- W_source @ T.T",
+          "mlp.up_proj.weight <- W_source @ T.T"
+        ],
+        "down_proj_transported": false,
+        "fisher_order": "source transport first; same-anchor post-pruning contextual Fisher second"
+      },
+      "source_before_sha256": {
+        "self_attn.q_proj.weight": "1839858bb3153a7d2907bbc4837cab44494ea4f8f73db2dac5a973f1500537c0",
+        "self_attn.k_proj.weight": "34776759a30508b301e6eeb4c03e74afc6e315a0e4005b788772f03267fa6bad",
+        "self_attn.v_proj.weight": "25ed7a7bfff05b2a63a9489ed945f49ed624baa5ffa7f971c263e4d3aade1d04",
+        "self_attn.o_proj.weight": "a8c4e7b3c03654158c39ea33456a291809aee2893e9dde1fa2d530da216b313c",
+        "self_attn.q_norm.weight": "21aa357e3be95df8e0b87310db2cf759d951d8c9a706c9e1bee207de27cbb87f",
+        "self_attn.k_norm.weight": "0dfad6f8b52d3a2c224e7cd2b5c1fe87db29b927a7d7fb4161f231df6df2ac02",
+        "mlp.gate_proj.weight": "4d745750b386ff30e96c0fe5ac21229e0672de87a3c4d30b7a877c333f250622",
+        "mlp.up_proj.weight": "b0b002f9bd65d4a6b4b37b6cf06139deb86a51ebc96fc27b4ebcff016f3e450b",
+        "mlp.down_proj.weight": "279864f62a9b78fa49dde314b363ca78f22fda503fbf8e9f64437ea6644a084a",
+        "input_layernorm.weight": "2974f6d5be715ca00edf542f4e51e5eb5ced2a292277c1974a92f5f6fec44871",
+        "post_attention_layernorm.weight": "a00da323dd47889f5a6238369523374a092cab49267ad69f4716d7b1c3778d5f"
+      },
+      "source_after_sha256": {
+        "self_attn.q_proj.weight": "1839858bb3153a7d2907bbc4837cab44494ea4f8f73db2dac5a973f1500537c0",
+        "self_attn.k_proj.weight": "34776759a30508b301e6eeb4c03e74afc6e315a0e4005b788772f03267fa6bad",
+        "self_attn.v_proj.weight": "25ed7a7bfff05b2a63a9489ed945f49ed624baa5ffa7f971c263e4d3aade1d04",
+        "self_attn.o_proj.weight": "a8c4e7b3c03654158c39ea33456a291809aee2893e9dde1fa2d530da216b313c",
+        "self_attn.q_norm.weight": "21aa357e3be95df8e0b87310db2cf759d951d8c9a706c9e1bee207de27cbb87f",
+        "self_attn.k_norm.weight": "0dfad6f8b52d3a2c224e7cd2b5c1fe87db29b927a7d7fb4161f231df6df2ac02",
+        "mlp.gate_proj.weight": "6b132cf55ede8fb805c51a5b57c84cddd3ac2e84d4d94d13538a0f3eae146ba2",
+        "mlp.up_proj.weight": "d8ae064ab88056091a57a96a007959b9d01bb6c1f037cdab35d76d5f5694b3ae",
+        "mlp.down_proj.weight": "279864f62a9b78fa49dde314b363ca78f22fda503fbf8e9f64437ea6644a084a",
+        "input_layernorm.weight": "2974f6d5be715ca00edf542f4e51e5eb5ced2a292277c1974a92f5f6fec44871",
+        "post_attention_layernorm.weight": "a00da323dd47889f5a6238369523374a092cab49267ad69f4716d7b1c3778d5f"
+      },
+      "changed": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight"
+      ]
+    },
+    "merge": {
+      "initializer": "wb",
+      "lambda_left": 0.0,
+      "lambda_right": 1.0,
+      "projection_names": [
+        "mlp.gate_proj.weight",
+        "mlp.up_proj.weight",
+        "mlp.down_proj.weight"
+      ],
+      "scope": "mlp",
+      "frozen_anchor_sha256": {
+        "self_attn.q_proj.weight": "1b6c758076acef0ff0bbf34e9ee7be3808252f432a10b0015a99b07a232ddf79",
+        "self_attn.k_proj.weight": "8d6f656be7538039543561a8c96dca260b3db7bdcb26946d9dca9a10101bb58f",
+        "self_attn.v_proj.weight": "ae85148c6da3808090619c005e94364db614bdec475df91ba4e312cb026fa377",
+        "self_attn.o_proj.weight": "e3c5cc19864068b28a406400c10d2704664356085511c7e44b587a1eab278d92",
+        "self_attn.q_norm.weight": "70223d2ee9393af355e7fa894d500b5c5bf032873b6b27cba6bb1f1b971cb904",
+        "self_attn.k_norm.weight": "df93c74989ee20de00c5875567ad98be1eb5d115d51bacb1dc615d22b15f488e",
+        "input_layernorm.weight": "f65024195899b2e5822f33d9c7d7c70442aaa262dd8bb1f4847d5c70f18d09e3",
+        "post_attention_layernorm.weight": "017c0603fff83a0a0231a2f3b9ae54ebe7f1d495c8d7092da5a10a87fadda049"
+      },
+      "anchor_before_sha256": {
+        "mlp.gate_proj.weight": "9f8d001778d2562d9f0deb7aa67ab4b374ee11bc56cf341dd3bbc2f89da978a9",
+        "mlp.up_proj.weight": "82d2d94c9a1082f87643386884771be030ad54381da7fbfda1931d886bff69bc",
+        "mlp.down_proj.weight": "4d5fefc568246a3abfa21725082f7fdf4dd62e7c580a1280aebe0ec60a2230cd"
+      },
+      "source_post_transport_sha256": {
+        "self_attn.q_proj.weight": "1839858bb3153a7d2907bbc4837cab44494ea4f8f73db2dac5a973f1500537c0",
+        "self_attn.k_proj.weight": "34776759a30508b301e6eeb4c03e74afc6e315a0e4005b788772f03267fa6bad",
+        "self_attn.v_proj.weight": "25ed7a7bfff05b2a63a9489ed945f49ed624baa5ffa7f971c263e4d3aade1d04",
+        "self_attn.o_proj.weight": "a8c4e7b3c03654158c39ea33456a291809aee2893e9dde1fa2d530da216b313c",
+        "self_attn.q_norm.weight": "21aa357e3be95df8e0b87310db2cf759d951d8c9a706c9e1bee207de27cbb87f",
+        "self_attn.k_norm.weight": "0dfad6f8b52d3a2c224e7cd2b5c1fe87db29b927a7d7fb4161f231df6df2ac02",
+        "mlp.gate_proj.weight": "6b132cf55ede8fb805c51a5b57c84cddd3ac2e84d4d94d13538a0f3eae146ba2",
+        "mlp.up_proj.weight": "d8ae064ab88056091a57a96a007959b9d01bb6c1f037cdab35d76d5f5694b3ae",
+        "mlp.down_proj.weight": "279864f62a9b78fa49dde314b363ca78f22fda503fbf8e9f64437ea6644a084a",
+        "input_layernorm.weight": "2974f6d5be715ca00edf542f4e51e5eb5ced2a292277c1974a92f5f6fec44871",
+        "post_attention_layernorm.weight": "a00da323dd47889f5a6238369523374a092cab49267ad69f4716d7b1c3778d5f"
+      },
+      "anchor_after_sha256": {
+        "mlp.gate_proj.weight": "6b132cf55ede8fb805c51a5b57c84cddd3ac2e84d4d94d13538a0f3eae146ba2",
+        "mlp.up_proj.weight": "d8ae064ab88056091a57a96a007959b9d01bb6c1f037cdab35d76d5f5694b3ae",
+        "mlp.down_proj.weight": "279864f62a9b78fa49dde314b363ca78f22fda503fbf8e9f64437ea6644a084a"
+      },
+      "norm_policy": "keep_Wa_including_QK_norms",
+      "source_mutated_by_merge": false,
+      "fisher_computed": false,
+      "fit": false,
+      "optimizer_steps": 0,
+      "backward_calls": 0
+    }
+  }
+]

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/2026-10-11_qwen3-base-nofit-merge4.md

@@ -0,0 +1,52 @@
+# Qwen3 Base no FiT merge controls
+
+Compare Wa, transported Wb, equal average, and corrected MKA initialization without FiT on our fixed nine-block Qwen3 Base span. Reuse the completed Fisher plus Transport no-FiT baseline. Report common-dense-teacher Local MSE, WikiText2 PPL, and Bench14 macro. MKA merges attention and MLP; the other four methods merge MLP only, so the MKA comparison also changes merge scope.
+
+## Resources and provenance
+
+- Session alias: `vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011`.
+- Branch: `codex/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011`; immutable execution commit recorded at launch and in each backup.
+- Instance 55359231, offer 51341854, machine 117301, Mississippi US. Four A100 SXM4 40 GB, reported allocated RAM 515807 MiB, disk 120 GB. Total listed cost USD 2.7444444444444445 per hour including disk, traffic extra. Offer reliability 0.9847917, download 1767 Mbps, upload 1891.5 Mbps.
+- Earlier instance 55357778, machine 149846, stalled in Vast container initialization with no SSH port. It never received code or started an experiment. Destroyed October 11 on user instruction to replace it; no experiment data lost.
+- Image `pytorch/pytorch:2.9.1-cuda12.8-cudnn9-devel`; transformers 5.15.1, datasets 3.6.0, huggingface_hub 1.33.0, lm_eval 0.4.12, scipy, scikit-learn. BF16 model/evaluation; source transport solves in FP32.
+- External engine: vendor base bundle 39e59afe, immutable three-file source overlay from Hub revision `61734e7b1a77fd279fe1e2584f7a0fdc26c175c2`, progressive-loader helpers and instruction-mask patch.
+
+## Inputs and merge rules
+
+Model `Qwen/Qwen3-8B-Base`, revision `49e3418fbbbca6ecbdf9608b4d22e5a407081db4`. Keep original anchor 12 and progressively remove original layers 13 through 21, span `[13,22)`, depth 36 to 27. Never switch to native MKA pair selection.
+
+Calibration is the historical non-streaming `DKYoon/SlimPajama-6B` shuffle, revision `b5f90f419b7489cdba26fdbc8c022fcb5562f968`, seed 42, 64 packed sequences of 1024 tokens, batch 2. Token SHA256 must equal `85a84b9a68cf0856fd363186d3a273860886b1c17f876cae145fd092454aff55`. This is not the concurrent mixed SlimPajama and MCQA-like experiment. Prepare and save exact token IDs once, share with all arms.
+
+Existing source feature Transport remains ON, ridge relative 0.001. It rewrites source MLP gate/up input projections only; down and attention projections are not transported. Save each transport matrix and pre/post operand hashes. In every cycle initialize from the actual post-transport source, not a stale pre-transport copy.
+
+Wa, Wb, Average merge the three MLP projection weights with respective left coefficients 1, 0, and 0.5. Attention, residual norms, and Q/K norms remain Wa. MKA merges all seven attention and MLP projection weights with the corrected local upstream coefficient, leaving all norms Wa. MKA geometry uses these same 64 calibration sequences, sequence mean pooling, sigma 8, alpha 0.5, two diffusion dimensions, five MI neighbors, 50 entropy neighbors, beta 1, MI seed 0, and is recomputed each stage before transport. This corrected local implementation is not an exact paper reproduction.
+
+No FiT loader, optimizer, additive U, backward pass, Fisher calculation, head permutation, LoRA, or residual-scale fitting is permitted in the four new arms. The transport ridge solve is the retained coordinate-alignment step, not MSE parameter matching.
+
+## Evaluation and retention
+
+Local MSE uses the same original dense teacher for every arm, including restored existing Fisher. Inputs are the first 64 packed 1024-token WikiText2 test windows under the HCHC full-stream packing. Capture dense layer12 input and layer21 output before final RMSNorm. Compare student anchor12 output with the dense output, verifying identical anchor inputs. Evaluate only; no optimization. Report squared difference sum divided by token count and hidden width, plus auxiliary energy-normalized MSE. BF16 eager activations, FP32 differences, FP64 aggregate. Exact evaluation input IDs and teacher-output hashes are retained.
+
+WikiText PPL preserves existing HCHC packing, sequence length 2048, BF16 eager, expected 145 windows and 296815 predicted tokens; batch 1 to fit 40 GB. Bench14 uses the established OpenCompass-five and lm-eval-nine zero-shot protocols with strict local caches. AVG means unweighted 14-task macro; separately report ZS12, MMLU, CMMLU. Preserve existing RACE protocols and earlier results.
+
+Existing Fisher scores are reused from `results/qwen3_8b_base_nofit_bench14_20261009/summary.json`, Transport ON row: PPL 15.585997450543665, ZS12 0.5125956256004165, MMLU 0.25630252100840334, CMMLU 0.2646347781039544, Bench14 0.4765774861655254. Restore its final anchor from immutable Hub revision `b2a437466b134a6311d3ab625b0b37f9aa1a96d6` and measure only new Local MSE. Do not confuse this no-FiT baseline with historical Fisher plus FiT.
+
+Keep all nine compact anchor stages, original model pin, stage topology, calibration and evaluation token IDs, every transport matrix, MKA coefficients/geometry, metrics and code. This permits future evaluation against each previous-stage teacher without retraining. Upload each arm under `LJYAI/paper_revision/runs/SESSION/20261011-qwen3-base-nofit-merge4/ARM`, verify every payload at its immutable revision, commit results on the remote session branch and recover/push locally. Do not return the replacement server without further instruction.
+
+## Commands and status
+
+Bootstrap: `bash scripts/bootstrap_qwen3_nofit_merge4.sh PROJECT EXTERNAL ROOT MODEL`.
+
+Controller: `bash scripts/launch_qwen3_nofit_merge4.sh PROJECT EXTERNAL ROOT MODEL SESSION`.
+
+GPU assignment: Wa 0, Wb 1, Average 2, MKA 3. Each must pass a two-stage smoke with all 64 calibration sequences before any production arm proceeds to nine stages, Local MSE, PPL, Bench14 and verified all-stage backup. Controller commands and PID provenance are recorded in `ROOT/execution.json`.
+
+Exact merge tests passed: four cases covering Wa, Wb, Average and MKA, BF16 deployed values, unchanged source operands and correct frozen parameters. Local syntax compilation passed; local Python lacks torch, so these CPU-only tests ran in an isolated temporary directory using the existing server's environment without changing its project or GPU workload. Replacement instance is preparing; no new pruning has started at this checkpoint.
+
+At 16:59 KST the replacement was running and SSH setup completed at `23.127.144.217:26556`; all four devices reported A100 SXM4 40 GB. Code commit `c5846595387bf856a3feb780d8c21d86feca194e` was sent by bundle to the isolated session branch. Bootstrap PID 576 and controller PID 577 launched at 07:59:48 UTC. The pinned evaluation archives were transferred and the controller is waiting on exact input preparation. At 17:00 KST dependencies were ready and model/corpus snapshots were downloading without failed markers.
+
+Local monitor PID 56032 checks every 300 seconds, writing `C:/Users/CELL/orca/artifacts/paper_revision/qwen3-base-nofit-merge4-55359231-20261011-monitor/poll.log`; on complete it recovers the result commit and pushes from this computer. It is a status/recovery process, not an autonomous failure-repair agent. All-stage compact packaging and backup use hard links within the same experiment filesystem to retain every stage without storing three physical copies. Hub uploads still contain complete standalone stage files.
+
+By 17:07 KST the historical calibration SHA256 matched exactly and all 131 local evaluation configurations validated without Hub requests. Common dense teacher input/output collection completed, and the restored Fisher anchor passed exact common-prefix-input equality; new evaluation-only Local MSE is 30.159363496315123, normalized MSE 0.5497266315473979. Teacher input IDs SHA256 is `3f1977a32c7a533356dbc14d142c64b470e67dc9942344ff2942e3b1f8b9e2a1`, layer12 input SHA256 `57378a13b898fd63fc40d2c0ccb209ec5d5b636026accc93521b928669200250`, layer21 output SHA256 `8c246a6cca66306de3cd208e8ec8ef5df8eb9d3e3976f16ad34329cb1216ab40`.
+
+By 17:08 KST all four two-stage smokes passed scope, exact data, zero-FiT and topology verification. All four nine-stage production processes started. Wa/Wb/Average cycles took about 8.1 seconds; MKA about 19 seconds including per-stage geometry. Inspected GPU memory remained below 40 GB. Remote test total is eight passing tests, including the explicit hard-link retry/storage check and existing compact regressions. Source provenance includes subsequent note/test-only commits `e6faf799` and `5546ad91`; merge implementation remains commit `c5846595`. Final four-arm metrics and Hub receipts are pending; do not report the existing Fisher Local MSE as a newly completed four-arm comparison.

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/abprune_compact.py

@@ -0,0 +1,284 @@
+"""Package and reconstruct compact ABPrune stage checkpoints.
+
+ABPrune already writes ``fused_layer.pt`` for every cycle.  This utility makes
+those files portable by pairing them with an explicit, immutable stage record;
+the dense base model plus that record is sufficient to reconstruct a student.
+"""
+from __future__ import annotations
+
+import argparse, hashlib, json, shutil
+from pathlib import Path
+from typing import Any
+
+import torch
+
+
+def copy_stage_state(src: Path, dst: Path, *, hard_link: bool = False) -> None:
+    """Optionally share immutable stage bytes within one experiment filesystem."""
+    if not hard_link:
+        shutil.copy2(src, dst)
+    elif dst.exists():
+        if not src.samefile(dst):
+            raise FileExistsError(f"Refusing to replace existing non-linked stage: {dst}")
+    else:
+        # Fail instead of silently consuming space if cross-device linking is
+        # unavailable. The caller explicitly selected the storage strategy.
+        dst.hardlink_to(src)
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(8 * 1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def post_merge_scale(source_cycle: Path) -> dict | None:
+    """Return the deployable post-merge scale stored for a cycle, if present."""
+    metadata_path = source_cycle / "cycle_metadata.json"
+    if not metadata_path.is_file():
+        return None
+    metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
+    distill = metadata.get("distill", {})
+    scale = distill.get("post_merge_nll_scale") or {}
+    source = "post_merge_nll"
+    if not scale.get("enabled"):
+        scale = (distill.get("reparam_stats") or {}).get("residual_scale") or {}
+        source = "scale_aware_fit"
+    if not scale.get("enabled"):
+        return None
+    gamma = scale["gamma"]
+    cumulative_gamma = scale["cumulative_gamma"]
+    if not isinstance(gamma, list):
+        gamma = float(gamma)
+    else:
+        gamma = [float(value) for value in gamma]
+    if not isinstance(cumulative_gamma, list):
+        cumulative_gamma = float(cumulative_gamma)
+    else:
+        cumulative_gamma = [float(value) for value in cumulative_gamma]
+    result = {
+        "enabled": True,
+        "mode": scale.get("mode", "residual"),
+        "scale_parameterization": scale.get("scale_parameterization", "scalar"),
+        "gamma": gamma,
+        "cumulative_gamma": cumulative_gamma,
+        "source": source,
+    }
+    for field in (
+        "optimization_mode",
+        "gamma_gradient_sources",
+        "theta_gradient_sources",
+        "nll_used",
+    ):
+        if field in scale:
+            result[field] = scale[field]
+    if "cumulative_gamma_statistics" in scale:
+        result["cumulative_gamma_statistics"] = scale["cumulative_gamma_statistics"]
+    if "raw" in scale and "ppl" in scale["raw"]:
+        result["calibration_raw_ppl"] = float(scale["raw"]["ppl"])
+    if "fitted" in scale and "ppl" in scale["fitted"]:
+        result["calibration_fitted_ppl"] = float(scale["fitted"]["ppl"])
+    return result
+
+
+def read_compact_metadata(compact_stage: Path) -> dict[str, Any]:
+    return json.loads((compact_stage / "metadata.json").read_text(encoding="utf-8"))
+
+
+def compact_scale_targets(metadata: dict[str, Any]) -> list[dict[str, Any]]:
+    """Return residual scales and current student indices for a compact stage."""
+    if metadata.get("format") == "abprune_compact_stage_v2":
+        active = [int(value) for value in metadata["active_original_layers"]]
+        current_index = {original: index for index, original in enumerate(active)}
+        targets = []
+        for state in metadata.get("retained_layer_states", []):
+            scale = state.get("post_merge_scale") or {}
+            if scale.get("enabled") and scale.get("mode") == "residual":
+                original = int(state["original_layer"])
+                targets.append(
+                    {
+                        "original_layer": original,
+                        "student_index": current_index[original],
+                        "scale": scale,
+                    }
+                )
+        return targets
+
+    scale = metadata.get("post_merge_scale") or {}
+    if scale.get("enabled") and scale.get("mode") == "residual":
+        return [
+            {
+                "original_layer": int(metadata["anchor_index"]),
+                "student_index": int(metadata["anchor_index"]),
+                "scale": scale,
+            }
+        ]
+    return []
+
+
+def _package_topology_aware(args, source: Path, out: Path, order: list[int]) -> None:
+    """Package cycles whose recipients may switch between pair boundaries."""
+    if int(getattr(args, "start_cycle", 1)) != 1:
+        raise ValueError("topology-aware compact packaging must start at cycle 1")
+
+    removed: set[int] = set()
+    latest_states: dict[int, dict[str, Any]] = {}
+    stages: list[dict[str, Any]] = []
+    original_layer_count: int | None = None
+
+    for cycle in range(1, args.cycles + 1):
+        source_cycle = source / f"cycle_{cycle}"
+        src = source_cycle / "fused_layer.pt"
+        if not src.is_file():
+            raise FileNotFoundError(src)
+        cycle_metadata_path = source_cycle / "cycle_metadata.json"
+        if not cycle_metadata_path.is_file():
+            raise FileNotFoundError(cycle_metadata_path)
+        cycle_metadata = json.loads(cycle_metadata_path.read_text(encoding="utf-8"))
+        recipient = int(cycle_metadata["recipient_original_layer"])
+        removed_original = int(cycle_metadata["removed_original_layer"])
+        recipient_side = str(cycle_metadata["recipient_side"])
+        if recipient_side not in {"left", "right"}:
+            raise ValueError(f"invalid recipient_side at cycle {cycle}: {recipient_side}")
+        if original_layer_count is None:
+            original_layer_count = int(cycle_metadata["num_layers_before"])
+        if removed_original in removed:
+            raise ValueError(f"original layer {removed_original} removed more than once")
+        if recipient in removed:
+            raise ValueError(f"cycle {cycle} selects removed recipient {recipient}")
+
+        removed.add(removed_original)
+        latest_states.pop(removed_original, None)
+        latest_states[recipient] = {
+            "original_layer": recipient,
+            "source_cycle": cycle,
+            "recipient_side": recipient_side,
+            "source_state": src,
+            "post_merge_scale": post_merge_scale(source_cycle),
+        }
+
+        stage_dir = out / f"stage_{cycle:02d}"
+        stage_dir.mkdir(exist_ok=True)
+        retained_states = []
+        for original, record in sorted(latest_states.items()):
+            state_name = f"layer_original_{original:04d}.pt"
+            state_path = stage_dir / state_name
+            copy_stage_state(record["source_state"], state_path, hard_link=bool(getattr(args, "hard_link", False)))
+            packaged = {
+                "original_layer": original,
+                "state_file": state_name,
+                "sha256": sha256(state_path),
+                "source_cycle": int(record["source_cycle"]),
+                "recipient_side": record["recipient_side"],
+            }
+            if record["post_merge_scale"] is not None:
+                packaged["post_merge_scale"] = record["post_merge_scale"]
+            retained_states.append(packaged)
+
+        assert original_layer_count is not None
+        active = [
+            original
+            for original in range(original_layer_count)
+            if original not in removed
+        ]
+        meta = {
+            "format": "abprune_compact_stage_v2",
+            "model": args.model,
+            "base_model_revision": args.base_revision,
+            "run_id": args.run_id,
+            "target_prune_count": args.cycles,
+            "stage": cycle,
+            "removed_count": len(removed),
+            "original_layer_count": original_layer_count,
+            "layer_order": order,
+            "latest_pair_index": order[cycle - 1],
+            "latest_recipient_side": recipient_side,
+            "latest_recipient_original_layer": recipient,
+            "latest_removed_original_layer": removed_original,
+            "removed_original_layers": sorted(removed),
+            "active_original_layers": active,
+            "retained_layer_states": retained_states,
+            "source_cycle": f"cycle_{cycle}",
+        }
+        (stage_dir / "metadata.json").write_text(
+            json.dumps(meta, indent=2) + "\n", encoding="utf-8"
+        )
+        stages.append(meta)
+
+    manifest = {
+        "format": "abprune_compact_manifest_v2",
+        "model": args.model,
+        "base_model_revision": args.base_revision,
+        "run_id": args.run_id,
+        "target_prune_count": args.cycles,
+        "original_layer_count": original_layer_count,
+        "layer_order": order,
+        "stages": stages,
+    }
+    (out / "manifest.json").write_text(
+        json.dumps(manifest, indent=2) + "\n", encoding="utf-8"
+    )
+
+
+def package(args):
+    source = Path(args.run_root); out = Path(args.output_root); out.mkdir(parents=True, exist_ok=True)
+    order = [int(x) for x in args.layer_order.replace(',', ' ').split()]
+    start_cycle = int(getattr(args, "start_cycle", 1))
+    expected_order = args.cycles - start_cycle + 1
+    if not 1 <= start_cycle <= args.cycles:
+        raise ValueError("start_cycle must be between 1 and cycles")
+    if len(order) != expected_order:
+        raise ValueError("layer_order length must equal cycles - start_cycle + 1")
+    first_metadata_path = source / f"cycle_{start_cycle}" / "cycle_metadata.json"
+    if first_metadata_path.is_file():
+        first_metadata = json.loads(first_metadata_path.read_text(encoding="utf-8"))
+        topology_fields = {
+            "recipient_side",
+            "recipient_original_layer",
+            "removed_original_layer",
+        }
+        if topology_fields.issubset(first_metadata):
+            _package_topology_aware(args, source, out, order)
+            return
+    stages = []
+    for cycle in range(start_cycle, args.cycles + 1):
+        order_index = cycle - start_cycle
+        source_cycle = source / f"cycle_{cycle}"
+        src = source_cycle / "fused_layer.pt"
+        if not src.exists(): raise FileNotFoundError(src)
+        dst_dir = out / f"stage_{cycle:02d}"; dst_dir.mkdir(exist_ok=True)
+        dst = dst_dir / "anchor_layer.pt"; copy_stage_state(src, dst, hard_link=bool(getattr(args, "hard_link", False)))
+        meta = {
+            "format": "abprune_compact_stage_v1", "model": args.model,
+            "base_model_revision": args.base_revision, "run_id": args.run_id,
+            "target_prune_count": args.cycles, "stage": cycle,
+            "removed_count": cycle, "anchor_index": order[order_index],
+            "layer_order": order,
+            "packaged_stage_range": [start_cycle, args.cycles],
+            "removed_original_layers": list(range(order[order_index] + 1, order[order_index] + cycle + 1)),
+            "source_cycle": f"cycle_{cycle}", "anchor_state_file": "anchor_layer.pt",
+            "sha256": sha256(dst),
+        }
+        scale = post_merge_scale(source_cycle)
+        if scale is not None:
+            meta["post_merge_scale"] = scale
+        (dst_dir / "metadata.json").write_text(json.dumps(meta, indent=2) + "\n", encoding="utf-8")
+        stages.append(meta)
+    manifest = {"format": "abprune_compact_manifest_v1", "model": args.model,
+        "base_model_revision": args.base_revision, "run_id": args.run_id,
+        "target_prune_count": args.cycles, "layer_order": order, "stages": stages}
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+
+
+def main():
+    p = argparse.ArgumentParser(); p.add_argument("--run-root", required=True); p.add_argument("--output-root", required=True)
+    p.add_argument("--model", required=True); p.add_argument("--base-revision", required=True); p.add_argument("--run-id", required=True)
+    p.add_argument("--cycles", type=int, required=True); p.add_argument("--layer-order", required=True)
+    p.add_argument("--start-cycle", type=int, default=1)
+    p.add_argument("--hard-link", action="store_true", help="Hard-link immutable stage weights on the same filesystem")
+    package(p.parse_args())
+
+
+if __name__ == "__main__": main()

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/abprune_stagewise_geometry.py

@@ -0,0 +1,227 @@
+"""Stage-wise activation geometry diagnostics for progressive ABPrune runs.
+
+The ABPrune checkpoints are treated as black-box students.  The dense model is
+the fixed teacher and boundaries are aligned by the original depth represented
+by the fused anchor (rather than by student layer index).
+"""
+from __future__ import annotations
+
+import argparse, gc, json, math
+from pathlib import Path
+from typing import Dict, Iterable
+
+import torch
+
+from .abprune_compact import read_compact_metadata
+from .abprune_recoverability import capture_module_output, load_model
+from .span_diagnostics import build_token_chunks, find_layers, get_dtype
+
+
+def _layer_container(model):
+    for path in ("model.layers", "model.decoder.layers", "transformer.h", "transformer.blocks", "gpt_neox.layers"):
+        parent = model
+        parts = path.split('.')
+        for part in parts[:-1]:
+            if not hasattr(parent, part): break
+            parent = getattr(parent, part)
+        else:
+            if hasattr(parent, parts[-1]):
+                container = getattr(parent, parts[-1])
+                if isinstance(container, torch.nn.ModuleList): return container
+    raise ValueError("Could not locate a mutable decoder layer ModuleList")
+
+
+def _reindex_layer_modules(layers) -> None:
+    """Align cache-facing layer indices with the compact decoder positions."""
+    for index, layer in enumerate(layers):
+        for module in layer.modules():
+            if hasattr(module, "layer_idx"):
+                module.layer_idx = index
+
+
+def load_compact_model(
+    base_ref: str,
+    compact_stage: Path,
+    *,
+    cycle: int | None,
+    anchor: int | None,
+    dtype: torch.dtype,
+    device: torch.device,
+    attn: str,
+    revision: str | None = None,
+):
+    """Reconstruct legacy single-anchor or topology-aware compact stages."""
+    model = load_model(base_ref, dtype=dtype, device=device, attn=attn, revision=revision)
+    container = _layer_container(model)
+    layers = list(container)
+    metadata = read_compact_metadata(compact_stage)
+    if metadata.get("format") == "abprune_compact_stage_v2":
+        if cycle is not None and int(metadata["stage"]) != int(cycle):
+            raise ValueError(
+                f"compact stage mismatch: metadata={metadata['stage']} requested={cycle}"
+            )
+        removed = {int(value) for value in metadata["removed_original_layers"]}
+        expected_active = [int(value) for value in metadata["active_original_layers"]]
+        active = [index for index in range(len(layers)) if index not in removed]
+        if active != expected_active:
+            raise ValueError(
+                f"compact topology mismatch: computed={active} metadata={expected_active}"
+            )
+        for entry in metadata["retained_layer_states"]:
+            original = int(entry["original_layer"])
+            state_path = compact_stage / entry["state_file"]
+            if not state_path.is_file():
+                raise FileNotFoundError(state_path)
+            state = torch.load(state_path, map_location="cpu", weights_only=True)
+            layers[original].load_state_dict(state, strict=True)
+        layers = [layers[index] for index in active]
+    else:
+        if cycle is None or anchor is None:
+            raise ValueError("legacy compact stages require cycle and anchor")
+        active = [
+            index
+            for index in range(len(layers))
+            if index not in range(anchor + 1, anchor + 1 + cycle)
+        ]
+        state = torch.load(
+            compact_stage / "anchor_layer.pt", map_location="cpu", weights_only=True
+        )
+        layers[anchor].load_state_dict(state, strict=True)
+        del layers[anchor + 1: anchor + 1 + cycle]
+    for idx in range(len(container) - 1, -1, -1):
+        del container[idx]
+    container.extend(layers)
+    _reindex_layer_modules(container)
+    if hasattr(model.config, "num_hidden_layers"):
+        model.config.num_hidden_layers = len(layers)
+    if getattr(model.config, "layer_types", None) is not None:
+        model.config.layer_types = [
+            model.config.layer_types[index] for index in active
+        ]
+    return model
+
+
+def _metric(student: torch.Tensor, teacher: torch.Tensor, mask: torch.Tensor) -> Dict[str, float]:
+    s = student.float().squeeze(0)[mask]
+    t = teacher.float().squeeze(0)[mask]
+    denom = t.square().sum().item()
+    sden = s.square().sum().item()
+    dot = (s * t).sum().item()
+    sn = s.norm(dim=-1).clamp_min(1e-12)
+    tn = t.norm(dim=-1).clamp_min(1e-12)
+    alpha = dot / max(sden, 1e-30)
+    return {
+        "nmse": float((s - t).square().sum().item() / max(denom, 1e-30)),
+        "scaled_nmse": float((alpha * s - t).square().sum().item() / max(denom, 1e-30)),
+        "cosine": float(((s * t).sum(dim=-1) / (sn * tn)).mean().item()),
+        "norm_ratio": float((sn / tn).mean().item()),
+        "optimal_alpha": float(alpha),
+        "tokens": int(s.shape[0]),
+    }
+
+
+def _teacher_cache(model, chunks, boundaries: Iterable[int], device):
+    wanted = sorted(set(boundaries))
+    cache = {b: [] for b in wanted}
+    layers = find_layers(model)
+    with torch.inference_mode():
+        for i, chunk in enumerate(chunks):
+            ids = chunk[None].to(device)
+            out = model(input_ids=ids, use_cache=False, output_hidden_states=True)
+            for b in wanted:
+                if b < 0 or b >= len(layers):
+                    raise ValueError(f"invalid teacher boundary {b}")
+                cache[b].append(out.hidden_states[b + 1].detach().cpu().half())
+            final_hidden = getattr(out, "last_hidden_state", None)
+            if final_hidden is None:
+                final_hidden = out.hidden_states[-1]
+            cache.setdefault("final", []).append(final_hidden.detach().cpu().half())
+            if (i + 1) % 4 == 0 or i + 1 == len(chunks):
+                print(f"[stagewise] teacher {i+1}/{len(chunks)}", flush=True)
+    return cache
+
+
+def _student_stage(model, chunks, teacher, *, anchor, original_end, device):
+    layers = find_layers(model)
+    if anchor >= len(layers):
+        raise ValueError(f"anchor {anchor} not present in {len(layers)} student layers")
+    local, final = [], []
+    target_local = teacher[original_end]
+    with torch.inference_mode():
+        for i, chunk in enumerate(chunks):
+            ids = chunk[None].to(device)
+            with capture_module_output(layers[anchor]) as hook:
+                out = model(input_ids=ids, use_cache=False, output_hidden_states=True)
+            local.append(hook["output"].cpu().half())
+            final_hidden = getattr(out, "last_hidden_state", None)
+            if final_hidden is None:
+                final_hidden = out.hidden_states[-1]
+            final.append(final_hidden.detach().cpu().half())
+    return local, final
+
+
+def run(args):
+    device = torch.device(args.device)
+    dtype = get_dtype(args.dtype)
+    from transformers import AutoTokenizer
+    tok = AutoTokenizer.from_pretrained(args.model)
+    chunks = build_token_chunks(tok, dataset_name="Salesforce/wikitext", dataset_config="wikitext-2-raw-v1",
+        split="test", text_field="text", seq_len=args.seq_len, num_sequences=args.num_sequences, seed=args.seed)
+    if len(chunks) != args.num_sequences:
+        raise RuntimeError(f"only built {len(chunks)} held-out chunks")
+    teacher_model = load_model(args.model, dtype=dtype, device=device, attn=args.attn)
+    depth = len(find_layers(teacher_model))
+    stages = list(args.stages) if args.stages else list(range(1, args.cycles + 1))
+    if not stages or any(stage < 1 or stage > args.cycles for stage in stages):
+        raise ValueError("--stages must contain values in [1, --cycles]")
+    boundaries = [args.anchor + stage for stage in stages]
+    teacher = _teacher_cache(teacher_model, chunks, boundaries, device)
+    # ``final`` is cached alongside the requested original block boundaries.
+    del teacher_model; gc.collect(); torch.cuda.empty_cache()
+    rows = []
+    for cycle in stages:
+        if args.compact_root:
+            ref = Path(args.compact_root) / f"stage_{cycle:02d}"
+            if not (ref / "metadata.json").exists(): raise FileNotFoundError(ref)
+            student = load_compact_model(args.model, ref, cycle=cycle, anchor=args.anchor,
+                                         dtype=dtype, device=device, attn=args.attn)
+        else:
+            ref = Path(args.student_root) / f"cycle_{cycle}" / "full_model"
+            if not (ref / "config.json").exists(): raise FileNotFoundError(ref)
+            student = load_model(str(ref), dtype=dtype, device=device, attn=args.attn)
+        local, final = _student_stage(student, chunks, teacher, anchor=args.anchor,
+                                       original_end=args.anchor + cycle, device=device)
+        for pos0_excluded in (True, False):
+            local_acc = {k: [] for k in ("nmse", "scaled_nmse", "cosine", "norm_ratio", "optimal_alpha")}
+            final_acc = {k: [] for k in local_acc}
+            for i in range(len(chunks)):
+                mask = torch.ones((args.seq_len,), dtype=torch.bool)
+                if pos0_excluded: mask[0] = False
+                lm = _metric(local[i], teacher[args.anchor + cycle][i], mask)
+                fm = _metric(final[i], teacher["final"][i], mask)
+                for k in local_acc: local_acc[k].append(lm[k]); final_acc[k].append(fm[k])
+            rows.append({"model": args.model, "target_prune_count": args.cycles, "stage": cycle,
+                "removed_count": cycle, "anchor": args.anchor, "merged_original_layers": list(range(args.anchor, args.anchor + cycle + 1)),
+                "teacher_boundary_index": args.anchor + cycle, "student_layer_index": args.anchor,
+                "position0_excluded": pos0_excluded,
+                "local": {k: float(sum(v)/len(v)) for k,v in local_acc.items()},
+                "final": {k: float(sum(v)/len(v)) for k,v in final_acc.items()},
+                "num_sequences": len(chunks), "seq_len": args.seq_len, "seed": args.seed})
+        print(f"[stagewise] completed cycle {cycle}/{args.cycles}", flush=True)
+        del student; gc.collect(); torch.cuda.empty_cache()
+    out = Path(args.output); out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps({"model": args.model, "anchor": args.anchor, "cycles": args.cycles, "rows": rows}, indent=2) + "\n")
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--model", required=True); p.add_argument("--student-root", required=True); p.add_argument("--anchor", type=int, required=True)
+    p.add_argument("--cycles", type=int, required=True); p.add_argument("--output", required=True)
+    p.add_argument("--stages", type=int, nargs="*", default=None,
+                   help="Optional subset of compact stages to analyze (default: every stage)")
+    p.add_argument("--compact-root", default=None, help="stage_XX/anchor_layer.pt package; overrides --student-root")
+    p.add_argument("--device", default="cuda"); p.add_argument("--dtype", default="bf16"); p.add_argument("--attn", default="eager")
+    p.add_argument("--num-sequences", type=int, default=16); p.add_argument("--seq-len", type=int, default=512); p.add_argument("--seed", type=int, default=12345)
+    args = p.parse_args(); run(args)
+
+if __name__ == "__main__": main()

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/aggregate_transport_rho_fit_14bench.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Combine the OpenCompass-five and lm-eval-nine evaluation reports."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+OPENCOMPASS_KEYS = {
+    "race_high": "race-high",
+    "race_middle": "race-middle",
+    "c3": "C3",
+    "cmnli": "cmnli",
+    "chid": "chid-dev",
+}
+LM_EVAL_KEYS = {
+    "piqa",
+    "winogrande",
+    "hellaswag",
+    "arc_challenge",
+    "arc_easy",
+    "openbookqa",
+    "sciq",
+    "mmlu",
+    "cmmlu",
+}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("run_root", type=Path)
+    args = parser.parse_args()
+
+    eval_dir = args.run_root / "eval"
+    opencompass = json.loads(
+        (eval_dir / "final_opencompass5.json").read_text(encoding="utf-8")
+    )
+    lm_eval = json.loads(
+        (eval_dir / "final_lmeval9.json").read_text(encoding="utf-8")
+    )
+    if set(lm_eval["task_scores"]) != LM_EVAL_KEYS:
+        raise RuntimeError(
+            f"unexpected lm-eval tasks: {sorted(lm_eval['task_scores'])}"
+        )
+
+    scores = {
+        name: opencompass["results"][source]["accuracy"]
+        for name, source in OPENCOMPASS_KEYS.items()
+    }
+    scores.update(lm_eval["task_scores"])
+    if len(scores) != 14 or any(not 0.0 <= float(value) <= 1.0 for value in scores.values()):
+        raise RuntimeError(f"invalid 14-task score set: {scores}")
+
+    report = {
+        "task_scores": scores,
+        "macro_mean_14": sum(scores.values()) / len(scores),
+        "tasks": list(scores),
+        "opencompass_protocol": opencompass["protocol"],
+        "lm_eval_num_fewshot": lm_eval["num_fewshot"],
+    }
+    output = eval_dir / "final_14bench.json"
+    output.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
+    (args.run_root / "BENCH14_COMPLETE").touch()
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/bootstrap_qwen3_nofit_bench8.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+set -euo pipefail
+project="$1"; root="$2"; model="$3"
+export HF_HOME=/workspace/.hf_home HF_TOKEN_PATH=/root/.cache/huggingface/token
+export HF_DATASETS_CACHE=/workspace/.hf_datasets36 PYTHONUNBUFFERED=1 OMP_NUM_THREADS=4
+mkdir -p "$root"
+trap 'rc=$?; if ((rc)); then touch "$root/BOOTSTRAP_FAILED"; fi' EXIT
+python -m pip install 'transformers==5.15.1' 'datasets==3.6.0' 'huggingface_hub==1.33.0' \
+ 'lm_eval==0.4.12' accelerate scipy sentencepiece protobuf
+python - "$root" "$model" <<'PY'
+from concurrent.futures import ThreadPoolExecutor
+from huggingface_hub import snapshot_download,hf_hub_download
+from pathlib import Path
+import hashlib,json,shutil,sys
+r=Path(sys.argv[1])
+prefix='runs/vast-paper_revision-qwen3-base-nofit-transport-zs6-54974094-20261009/20261009-qwen3-base-nofit-transport-zs6'
+pins={'off':'71252a138f0f97349f29c743206160b77e45899e','on':'b2a437466b134a6311d3ab625b0b37f9aa1a96d6'}
+def base():
+ return snapshot_download('Qwen/Qwen3-8B-Base',revision='49e3418fbbbca6ecbdf9608b4d22e5a407081db4',
+  local_dir=sys.argv[2],allow_patterns=['*.json','*.safetensors','tokenizer*','*.model','*.jinja'],max_workers=8)
+def restore(arm):
+ rev=pins[arm]; path=f'{prefix}/{arm}'
+ manifest=json.loads(Path(hf_hub_download('LJYAI/paper_revision',f'{path}/manifest.json',revision=rev)).read_text())
+ out=r/'full'/arm; restored=[]
+ for item in manifest['files']:
+  rel=item['path']
+  if not (rel.startswith('compact/stage_09/') or rel=='eval/zs6.json'): continue
+  src=Path(hf_hub_download('LJYAI/paper_revision',f'{path}/{rel}',revision=rev))
+  assert src.stat().st_size==item['size']
+  assert hashlib.sha256(src.read_bytes()).hexdigest()==item['sha256']
+  dst=out/rel;dst.parent.mkdir(parents=True,exist_ok=True);shutil.copy2(src,dst);restored.append(item)
+ meta=json.loads((out/'compact/stage_09/metadata.json').read_text())
+ assert meta['anchor_index']==12 and meta['removed_original_layers']==list(range(13,22))
+ assert meta['stage']==9 and meta['format']=='abprune_compact_stage_v1'
+ assert (out/'eval/zs6.json').is_file() and len(list((out/'compact/stage_09').glob('*.pt')))==1
+ receipt={'arm':arm,'repository':'LJYAI/paper_revision','path':path,'revision':rev,
+          'restored_files':restored,'all_restored_hashes_match':True}
+ (out/'restore_receipt.json').write_text(json.dumps(receipt,indent=2)+'\n')
+ return receipt
+with ThreadPoolExecutor(max_workers=3) as p:
+ futures=[p.submit(base),p.submit(restore,'off'),p.submit(restore,'on')]
+ for f in futures: print('PINNED_INPUT_READY',f.result(),flush=True)
+(r/'BASE_READY').touch()
+PY
+while [[ ! -f "$root/EVAL_ASSETS_READY" ]]; do sleep 3; done
+python - "$root" <<'PY'
+from pathlib import Path
+import hashlib,sys
+r=Path(sys.argv[1])
+for name,expected in [('opencompass5-data.tar.gz','b49605cc272cee94ddc177d2350e06d70f0f610926a2abf20c8ccd35ad8cd353'),
+ ('lmeval-cache-131.tar.gz','e5a319ed00b52181df3d80e47e4939e78fddd393803c29a9bcb63c2dd8a6d468')]:
+ assert hashlib.sha256((r/name).read_bytes()).hexdigest()==expected
+print('EVALUATION_ARCHIVE_HASHES_VERIFIED',flush=True)
+PY
+mkdir -p "$root/eval_data"
+tar -xzf "$root/opencompass5-data.tar.gz" -C "$root/eval_data"
+tar -xzf "$root/lmeval-cache-131.tar.gz" -C "$root"
+HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 python "$project/scripts/prepare_lmeval9_local_cache.py" "$root/lmeval_cache" --validate-local
+touch "$root/EVAL_READY" "$root/BOOTSTRAP_COMPLETE"

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/bootstrap_qwen3_nofit_merge4.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+project="$1"; external="$2"; root="$3"; model="$4"
+export HF_HOME=/workspace/.hf_home HF_TOKEN_PATH=/root/.cache/huggingface/token
+export HF_DATASETS_CACHE=/workspace/.hf_datasets36 PYTHONUNBUFFERED=1
+export PYTHONPATH="$external/src:$project/src:$project" TOKENIZERS_PARALLELISM=false OMP_NUM_THREADS=4
+mkdir -p "$root"
+trap 'rc=$?; if ((rc)); then touch "$root/BOOTSTRAP_FAILED"; fi' EXIT
+# Pinned engine + dense model + the original non-streaming SlimPajama cache.
+# One download/cache preparation is shared by all four GPU workers.
+bash "$project/scripts/bootstrap_qwen3_8b_mergeinit_fit2.sh" "$project" "$external" "$root" "$model"
+python -m pytest -q "$project/tests/test_nofit_merge_control.py" > "$root/unit_tests.log" 2>&1
+python "$project/scripts/prepare_qwen3_nofit_merge_inputs.py" --external-root "$external" \
+ --model "$model" --output "$root/inputs" > "$root/data_prepare.log" 2>&1
+touch "$root/DATA_READY"
+python - "$root" <<'PY'
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+from datasets import load_dataset
+import hashlib,json,shutil,sys
+r=Path(sys.argv[1]); prefix='runs/vast-paper_revision-qwen3-base-nofit-transport-zs6-54974094-20261009/20261009-qwen3-base-nofit-transport-zs6/on'
+revision='b2a437466b134a6311d3ab625b0b37f9aa1a96d6'
+manifest=json.loads(Path(hf_hub_download('LJYAI/paper_revision',prefix+'/manifest.json',revision=revision)).read_text())
+restored=[]
+for item in manifest['files']:
+ if not item['path'].startswith('compact/stage_09/'): continue
+ src=Path(hf_hub_download('LJYAI/paper_revision',prefix+'/'+item['path'],revision=revision))
+ assert src.stat().st_size==item['size'] and hashlib.sha256(src.read_bytes()).hexdigest()==item['sha256']
+ dst=r/'fisher_reference'/item['path'];dst.parent.mkdir(parents=True,exist_ok=True);shutil.copy2(src,dst);restored.append(item)
+assert len(restored)==2
+(r/'fisher_reference/restore_receipt.json').write_text(json.dumps(dict(repo='LJYAI/paper_revision',path=prefix,revision=revision,files=restored,verified=True),indent=2)+'\n')
+load_dataset('Salesforce/wikitext','wikitext-2-raw-v1')
+PY
+python "$project/scripts/prepare_offline_ppl_cache.py" "$root"
+while [[ ! -f "$root/EVAL_ASSETS_READY" ]]; do sleep 3; done
+python - "$root" <<'PY'
+import hashlib,sys
+from pathlib import Path
+r=Path(sys.argv[1])
+for name,h in [('opencompass5-data.tar.gz','b49605cc272cee94ddc177d2350e06d70f0f610926a2abf20c8ccd35ad8cd353'),('lmeval-cache-131.tar.gz','e5a319ed00b52181df3d80e47e4939e78fddd393803c29a9bcb63c2dd8a6d468')]:
+ assert hashlib.sha256((r/name).read_bytes()).hexdigest()==h
+PY
+mkdir -p "$root/eval_data"
+tar -xzf "$root/opencompass5-data.tar.gz" -C "$root/eval_data"
+tar -xzf "$root/lmeval-cache-131.tar.gz" -C "$root"
+HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 python "$project/scripts/prepare_lmeval9_local_cache.py" "$root/lmeval_cache" --validate-local
+touch "$root/EVAL_READY"
+CUDA_VISIBLE_DEVICES=0 HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 TRANSFORMERS_OFFLINE=1 \
+ python "$project/scripts/qwen3_nofit_local_mse.py" --model "$model" --cache "$root/local_mse_reference" \
+ --wikitext-cache "$root/wikitext2_cache" --prepare > "$root/local_mse_prepare.log" 2>&1
+touch "$root/COMMON_TEACHER_READY"
+CUDA_VISIBLE_DEVICES=0 HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 TRANSFORMERS_OFFLINE=1 \
+ python "$project/scripts/qwen3_nofit_local_mse.py" --model "$model" --cache "$root/local_mse_reference" \
+ --compact-stage "$root/fisher_reference/compact/stage_09" --output "$root/fisher_reference/local_mse.json" > "$root/fisher_mse.log" 2>&1
+touch "$root/INPUTS_READY"

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/common_lm_data.py

@@ -0,0 +1,651 @@
+#!/usr/bin/env python3
+"""Shared LM dataset helpers for fair cross-method comparisons."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Iterable, Iterator, List, Optional, Tuple
+
+import torch
+
+from dm500_rows import configured_indices, dataset_revision_kwargs, select_exact_rows
+
+try:
+    from datasets import load_dataset
+    from datasets import Dataset as HFDataset
+except Exception:  # pragma: no cover - optional dependency
+    load_dataset = None
+    HFDataset = None
+
+
+def _normalize_config(config: Optional[str]) -> Optional[str]:
+    if config is None:
+        return None
+    if config.strip().lower() in {"none", "null", "-"}:
+        return None
+    return config
+
+
+def guess_text_field(dataset) -> str:
+    if hasattr(dataset, "column_names") and dataset.column_names:
+        if "text" in dataset.column_names:
+            return "text"
+        return dataset.column_names[0]
+    if hasattr(dataset, "features"):
+        names = list(dataset.features.keys())
+        if "text" in names:
+            return "text"
+        if names:
+            return names[0]
+    return "text"
+
+
+def normalize_dataset_name(name: str) -> str:
+    normalized = name.strip().lower()
+    aliases = {
+        "bookcorpus": "bookcorpus",
+        "boockcorpus": "bookcorpus",
+        "slimpajama": "slimpajama",
+        "dkyoon/slimpajama-6b": "slimpajama",
+        "slimorca": "slimorca",
+        "orca": "slimorca",
+        "open-orca/slimorca": "slimorca",
+        "fineweb": "fineweb",
+        "huggingfacefw/fineweb": "fineweb",
+    }
+    if normalized not in aliases:
+        raise ValueError(f"Unsupported dataset: {name}")
+    return aliases[normalized]
+
+
+def resolve_dataset_spec(
+    name: str,
+    config: Optional[str] = None,
+    split: str = "train",
+) -> Tuple[str, Optional[str], str]:
+    normalized = normalize_dataset_name(name)
+    if normalized == "bookcorpus":
+        return "bookcorpus", _normalize_config(config), split
+    if normalized == "slimpajama":
+        return "DKYoon/SlimPajama-6B", _normalize_config(config), split
+    if normalized == "slimorca":
+        return "Open-Orca/SlimOrca", _normalize_config(config), split
+    if normalized == "fineweb":
+        return "HuggingFaceFW/fineweb", _normalize_config(config), split
+    raise ValueError(f"Unsupported dataset: {name}")
+
+
+def is_instruction_dataset(name: str) -> bool:
+    return normalize_dataset_name(name) == "slimorca"
+
+
+def should_stream_dataset(name: str) -> bool:
+    return normalize_dataset_name(name) == "fineweb"
+
+
+def load_resolved_dataset(
+    dataset_name: str,
+    hf_name: str,
+    hf_config: Optional[str],
+    hf_split: str,
+):
+    kwargs = {
+        "split": hf_split,
+        **dataset_revision_kwargs(),
+    }
+    if should_stream_dataset(dataset_name):
+        kwargs["streaming"] = True
+    return load_dataset(hf_name, hf_config, **kwargs)
+
+
+def _build_messages_text(messages: List[Dict[str, str]]) -> str:
+    chunks: List[str] = []
+    for message in messages:
+        role = str(message.get("role", "")).strip().title() or "User"
+        content = str(message.get("content", "")).strip()
+        if content:
+            chunks.append(f"{role}: {content}")
+    return "\n\n".join(chunks)
+
+
+def _build_slimorca_text(row: Dict[str, object]) -> Optional[str]:
+    conversations = row.get("conversations")
+    if not isinstance(conversations, list) or len(conversations) < 2:
+        return None
+
+    start_idx = 0
+    if str(conversations[0].get("from", "")).strip().lower() != "human":
+        start_idx = 1
+    if start_idx + 1 >= len(conversations):
+        return None
+
+    user_turn = conversations[start_idx]
+    assistant_turn = conversations[start_idx + 1]
+    if (
+        str(user_turn.get("from", "")).strip().lower() != "human"
+        or str(assistant_turn.get("from", "")).strip().lower() != "gpt"
+    ):
+        return None
+
+    user_content = str(user_turn.get("value", "")).strip()
+    assistant_content = str(assistant_turn.get("value", "")).strip()
+    if not user_content or not assistant_content:
+        return None
+
+    messages = [
+        {"role": "user", "content": user_content},
+        {"role": "assistant", "content": assistant_content},
+    ]
+    return _build_messages_text(messages)
+
+
+def _build_slimorca_record(row: Dict[str, object]) -> Optional[Dict[str, object]]:
+    conversations = row.get("conversations")
+    if not isinstance(conversations, list) or len(conversations) < 2:
+        return None
+
+    start_idx = 0
+    if str(conversations[0].get("from", "")).strip().lower() != "human":
+        start_idx = 1
+    if start_idx + 1 >= len(conversations):
+        return None
+
+    user_turn = conversations[start_idx]
+    assistant_turn = conversations[start_idx + 1]
+    if (
+        str(user_turn.get("from", "")).strip().lower() != "human"
+        or str(assistant_turn.get("from", "")).strip().lower() != "gpt"
+    ):
+        return None
+
+    user_content = str(user_turn.get("value", "")).strip()
+    assistant_content = str(assistant_turn.get("value", "")).strip()
+    if not user_content or not assistant_content:
+        return None
+
+    messages = [
+        {"role": "user", "content": user_content},
+        {"role": "assistant", "content": assistant_content},
+    ]
+    return {"messages": messages, "text": _build_messages_text(messages)}
+
+
+def _tokenize_instruction_record(record: Dict[str, object], tokenizer) -> List[int]:
+    chat_template = getattr(tokenizer, "chat_template", None)
+    if (
+        "messages" in record
+        and hasattr(tokenizer, "apply_chat_template")
+        and chat_template
+    ):
+        ids = tokenizer.apply_chat_template(
+            record["messages"],
+            tokenize=True,
+            add_generation_prompt=False,
+        )
+    else:
+        ids = tokenizer.encode(str(record.get("text", "")), add_special_tokens=False)
+
+    if hasattr(ids, "input_ids"):
+        ids = ids.input_ids
+    if isinstance(ids, torch.Tensor):
+        return ids.tolist()
+    if isinstance(ids, list):
+        return ids
+    return list(ids)
+
+
+def _round_up_to_multiple(value: int, multiple: int) -> int:
+    if multiple <= 1:
+        return value
+    return ((value + multiple - 1) // multiple) * multiple
+
+
+def _sample_dataset_rows(dataset, target: int, seed: int) -> List[Dict[str, object]]:
+    if target <= 0:
+        return []
+    exact = select_exact_rows(dataset, target)
+    if exact is not None:
+        return [row for row in exact]
+    try:
+        dataset = dataset.shuffle(seed=seed)
+    except Exception:
+        pass
+
+    if hasattr(dataset, "__len__"):
+        limit = min(target, len(dataset))
+        dataset = dataset.select(range(limit))
+        return [row for row in dataset]
+
+    rows = []
+    for row in dataset:
+        rows.append(row)
+        if len(rows) >= target:
+            break
+    return rows
+
+
+def _iter_dataset_rows(dataset, seed: int) -> Iterator[Dict[str, object]]:
+    exact = select_exact_rows(dataset)
+    if exact is not None:
+        for row in exact:
+            yield row
+        return
+    try:
+        dataset = dataset.shuffle(seed=seed)
+    except Exception:
+        pass
+    for row in dataset:
+        yield row
+
+
+def load_named_texts(
+    dataset_name: str,
+    *,
+    config: Optional[str] = None,
+    split: str = "train",
+    text_field: Optional[str] = None,
+    num_samples: int = 0,
+    seed: int = 0,
+) -> List[str]:
+    if load_dataset is None:
+        raise SystemExit("datasets is required for shared LM dataloaders")
+
+    hf_name, hf_config, hf_split = resolve_dataset_spec(dataset_name, config, split)
+    dataset = load_resolved_dataset(dataset_name, hf_name, hf_config, hf_split)
+    rows = dataset if num_samples <= 0 else _sample_dataset_rows(dataset, num_samples, seed)
+    field = text_field or guess_text_field(dataset)
+
+    texts: List[str] = []
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        if is_instruction_dataset(dataset_name):
+            value = _build_slimorca_text(row)
+        else:
+            value = row.get(field, None)
+        if isinstance(value, str) and value.strip():
+            texts.append(value)
+    return texts
+
+
+def build_token_chunks_from_rows(
+    rows: Iterable[Dict[str, object]],
+    *,
+    dataset_name: Optional[str] = None,
+    text_field: str,
+    tokenizer,
+    seq_len: int,
+    num_sequences: int = 0,
+    add_bos: bool = False,
+    max_rows: int = 0,
+) -> List[torch.Tensor]:
+    chunks: List[torch.Tensor] = []
+    buffer: List[int] = []
+    limit = None if num_sequences <= 0 else num_sequences
+    rows_seen = 0
+
+    for row in rows:
+        if max_rows > 0 and rows_seen >= max_rows:
+            break
+        rows_seen += 1
+
+        if not isinstance(row, dict):
+            continue
+        if dataset_name is not None and is_instruction_dataset(dataset_name):
+            value = _build_slimorca_text(row)
+        else:
+            value = row.get(text_field, None)
+        if not isinstance(value, str) or not value.strip():
+            continue
+
+        ids = tokenizer.encode(value, add_special_tokens=False)
+        if add_bos and tokenizer.bos_token_id is not None:
+            ids = [tokenizer.bos_token_id] + ids
+        if not ids:
+            continue
+
+        buffer.extend(ids)
+        while len(buffer) >= seq_len and (limit is None or len(chunks) < limit):
+            chunk = buffer[:seq_len]
+            buffer = buffer[seq_len:]
+            chunks.append(torch.tensor(chunk, dtype=torch.long))
+        if limit is not None and len(chunks) >= limit:
+            break
+
+    return chunks
+
+
+def collect_texts_from_rows(
+    rows: Iterable[Dict[str, object]],
+    *,
+    dataset_name: Optional[str] = None,
+    text_field: str,
+    tokenizer,
+    target_tokens: int = 0,
+    add_bos: bool = False,
+    max_rows: int = 0,
+) -> List[str]:
+    texts: List[str] = []
+    token_count = 0
+    rows_seen = 0
+
+    for row in rows:
+        if max_rows > 0 and rows_seen >= max_rows:
+            break
+        rows_seen += 1
+
+        if not isinstance(row, dict):
+            continue
+        if dataset_name is not None and is_instruction_dataset(dataset_name):
+            value = _build_slimorca_text(row)
+        else:
+            value = row.get(text_field, None)
+        if not isinstance(value, str) or not value.strip():
+            continue
+
+        texts.append(value)
+        if target_tokens > 0:
+            ids = tokenizer.encode(value, add_special_tokens=False)
+            if add_bos and tokenizer.bos_token_id is not None:
+                ids = [tokenizer.bos_token_id] + ids
+            token_count += len(ids)
+            if token_count >= target_tokens:
+                break
+
+    return texts
+
+
+def build_token_chunks(
+    texts: Iterable[str],
+    tokenizer,
+    seq_len: int,
+    num_sequences: int = 0,
+    add_bos: bool = False,
+) -> List[torch.Tensor]:
+    chunks: List[torch.Tensor] = []
+    buffer: List[int] = []
+    limit = None if num_sequences <= 0 else num_sequences
+
+    for text in texts:
+        ids = tokenizer.encode(text, add_special_tokens=False)
+        if add_bos and tokenizer.bos_token_id is not None:
+            ids = [tokenizer.bos_token_id] + ids
+        if not ids:
+            continue
+
+        buffer.extend(ids)
+        while len(buffer) >= seq_len and (limit is None or len(chunks) < limit):
+            chunk = buffer[:seq_len]
+            buffer = buffer[seq_len:]
+            chunks.append(torch.tensor(chunk, dtype=torch.long))
+        if limit is not None and len(chunks) >= limit:
+            break
+
+    return chunks
+
+
+class TokenChunkDataset(torch.utils.data.Dataset):
+    def __init__(self, chunks: List[torch.Tensor]) -> None:
+        self.chunks = chunks
+
+    def __len__(self) -> int:
+        return len(self.chunks)
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        input_ids = self.chunks[idx]
+        attention_mask = torch.ones_like(input_ids)
+        return {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+            "labels": input_ids.clone(),
+        }
+
+
+class TokenOnlyDataset(torch.utils.data.Dataset):
+    def __init__(self, chunks: List[torch.Tensor]) -> None:
+        self.chunks = chunks
+
+    def __len__(self) -> int:
+        return len(self.chunks)
+
+    def __getitem__(self, idx: int) -> torch.Tensor:
+        return self.chunks[idx]
+
+
+class TokenInputMaskDataset(torch.utils.data.Dataset):
+    def __init__(self, chunks: List[torch.Tensor]) -> None:
+        self.chunks = chunks
+
+    def __len__(self) -> int:
+        return len(self.chunks)
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        input_ids = self.chunks[idx]
+        return {
+            "input_ids": input_ids,
+            "attention_mask": torch.ones_like(input_ids),
+        }
+
+
+@dataclass
+class SharedLMDataSpec:
+    dataset: str
+    config: Optional[str] = None
+    split: str = "train"
+    text_field: Optional[str] = None
+    num_samples: int = 0
+    seq_len: int = 2048
+    num_sequences: int = 0
+    target_tokens: int = 0
+    batch_size: int = 1
+    shuffle: bool = False
+    num_workers: int = 0
+    seed: int = 0
+    add_bos: bool = False
+
+
+def build_chunks(spec: SharedLMDataSpec, tokenizer) -> List[torch.Tensor]:
+    if load_dataset is None:
+        raise SystemExit("datasets is required for shared LM dataloaders")
+
+    hf_name, hf_config, hf_split = resolve_dataset_spec(spec.dataset, spec.config, spec.split)
+    dataset = load_resolved_dataset(spec.dataset, hf_name, hf_config, hf_split)
+
+    target_sequences = spec.num_sequences
+    if spec.target_tokens > 0:
+        token_sequences = (spec.target_tokens + spec.seq_len - 1) // spec.seq_len
+        target_sequences = max(target_sequences, token_sequences)
+    row_limit = spec.num_samples if target_sequences <= 0 else 0
+
+    rows = _iter_dataset_rows(dataset, spec.seed)
+    text_field = spec.text_field or guess_text_field(dataset)
+    chunks = build_token_chunks_from_rows(
+        rows,
+        dataset_name=spec.dataset,
+        text_field=text_field,
+        tokenizer=tokenizer,
+        seq_len=spec.seq_len,
+        num_sequences=target_sequences,
+        add_bos=spec.add_bos,
+        max_rows=row_limit,
+    )
+    return chunks
+
+
+def build_dataloader(spec: SharedLMDataSpec, tokenizer) -> torch.utils.data.DataLoader:
+    chunks = build_chunks(spec, tokenizer)
+    dataset = TokenChunkDataset(chunks)
+    return torch.utils.data.DataLoader(
+        dataset,
+        batch_size=spec.batch_size,
+        shuffle=spec.shuffle,
+        num_workers=spec.num_workers,
+    )
+
+
+def build_text_dataloader(spec: SharedLMDataSpec, tokenizer) -> torch.utils.data.DataLoader:
+    if load_dataset is None:
+        raise SystemExit("datasets is required for shared LM dataloaders")
+
+    hf_name, hf_config, hf_split = resolve_dataset_spec(spec.dataset, spec.config, spec.split)
+    dataset = load_resolved_dataset(spec.dataset, hf_name, hf_config, hf_split)
+    rows = _iter_dataset_rows(dataset, spec.seed)
+    text_field = spec.text_field or guess_text_field(dataset)
+    row_limit = spec.num_samples
+    texts = collect_texts_from_rows(
+        rows,
+        dataset_name=spec.dataset,
+        text_field=text_field,
+        tokenizer=tokenizer,
+        target_tokens=spec.target_tokens,
+        add_bos=spec.add_bos,
+        max_rows=row_limit,
+    )
+    return torch.utils.data.DataLoader(
+        texts,
+        batch_size=spec.batch_size,
+        shuffle=spec.shuffle,
+        num_workers=spec.num_workers,
+        drop_last=True,
+    )
+
+
+def build_uidl_post_train_dataloader(
+    spec: SharedLMDataSpec,
+    tokenizer,
+) -> torch.utils.data.DataLoader:
+    dataset = TokenChunkDataset(build_chunks(spec, tokenizer))
+    return torch.utils.data.DataLoader(
+        dataset,
+        batch_size=spec.batch_size,
+        shuffle=spec.shuffle,
+        num_workers=spec.num_workers,
+    )
+
+
+def build_uidl_similarity_dataloader(
+    spec: SharedLMDataSpec,
+    tokenizer,
+) -> torch.utils.data.DataLoader:
+    dataset = TokenInputMaskDataset(build_chunks(spec, tokenizer))
+    return torch.utils.data.DataLoader(
+        dataset,
+        batch_size=spec.batch_size,
+        shuffle=spec.shuffle,
+        num_workers=spec.num_workers,
+    )
+
+
+def build_shortened_llm_dataloader(
+    spec: SharedLMDataSpec,
+    tokenizer,
+) -> torch.utils.data.DataLoader:
+    dataset = TokenOnlyDataset(build_chunks(spec, tokenizer))
+    return torch.utils.data.DataLoader(
+        dataset,
+        batch_size=spec.batch_size,
+        shuffle=spec.shuffle,
+        num_workers=spec.num_workers,
+    )
+
+
+def build_shortened_llm_examples(spec: SharedLMDataSpec, tokenizer) -> torch.Tensor:
+    chunks = build_chunks(spec, tokenizer)
+    if not chunks:
+        return torch.empty((0, spec.seq_len), dtype=torch.long)
+    return torch.stack(chunks, dim=0)
+
+
+def build_llmpruner_examples(spec: SharedLMDataSpec, tokenizer) -> torch.Tensor:
+    chunks = build_chunks(spec, tokenizer)
+    if not chunks:
+        return torch.empty((0, spec.seq_len), dtype=torch.long)
+    return torch.stack(chunks, dim=0)
+
+
+def build_replaceme_dataloader(
+    spec: SharedLMDataSpec,
+    tokenizer,
+) -> torch.utils.data.DataLoader:
+    return build_text_dataloader(spec, tokenizer)
+
+
+def build_hf_causal_dataset(spec: SharedLMDataSpec, tokenizer):
+    if HFDataset is None:
+        raise SystemExit("datasets is required for shared LM dataloaders")
+
+    if is_instruction_dataset(spec.dataset):
+        if load_dataset is None:
+            raise SystemExit("datasets is required for shared LM dataloaders")
+
+        hf_name, hf_config, hf_split = resolve_dataset_spec(spec.dataset, spec.config, spec.split)
+        dataset = load_resolved_dataset(spec.dataset, hf_name, hf_config, hf_split)
+        rows = dataset if spec.num_samples <= 0 else _sample_dataset_rows(dataset, spec.num_samples, spec.seed)
+
+        records: List[Dict[str, object]] = []
+        tokenized_records: List[List[int]] = []
+        max_observed_len = 0
+        for row in rows:
+            if not isinstance(row, dict):
+                continue
+            record = _build_slimorca_record(row)
+            if record is None:
+                continue
+            ids = _tokenize_instruction_record(record, tokenizer)
+            if not ids:
+                continue
+            ids = ids[: spec.seq_len]
+            if not ids:
+                continue
+            records.append(record)
+            tokenized_records.append(ids)
+            max_observed_len = max(max_observed_len, len(ids))
+
+        if not tokenized_records:
+            raise SystemExit(
+                f"No instruction samples built for dataset={spec.dataset} split={spec.split}."
+            )
+
+        if configured_indices() is not None:
+            effective_max_len = spec.seq_len
+        else:
+            effective_max_len = min(spec.seq_len, max_observed_len)
+            effective_max_len = min(spec.seq_len, _round_up_to_multiple(effective_max_len, 8))
+        print(
+            "[common_lm_data] "
+            f"dataset={spec.dataset} split={spec.split} samples={len(tokenized_records)} "
+            f"max_observed_len={max_observed_len} effective_max_len={effective_max_len}"
+        )
+        pad_id = tokenizer.pad_token_id
+        if pad_id is None:
+            pad_id = tokenizer.eos_token_id or 0
+
+        input_ids_payload: List[List[int]] = []
+        attention_masks_payload: List[List[int]] = []
+        labels_payload: List[List[int]] = []
+        for ids in tokenized_records:
+            ids = ids[:effective_max_len]
+            attention_mask = [1] * len(ids)
+            if len(ids) < effective_max_len:
+                pad_len = effective_max_len - len(ids)
+                ids = ids + [pad_id] * pad_len
+                attention_mask = attention_mask + [0] * pad_len
+            input_ids_payload.append(ids)
+            attention_masks_payload.append(attention_mask)
+            labels_payload.append(list(ids))
+
+        return HFDataset.from_dict(
+            {
+                "input_ids": input_ids_payload,
+                "attention_mask": attention_masks_payload,
+                "labels": labels_payload,
+            }
+        )
+
+    chunks = build_chunks(spec, tokenizer)
+    payload = {
+        "input_ids": [chunk.tolist() for chunk in chunks],
+        "attention_mask": [torch.ones_like(chunk).tolist() for chunk in chunks],
+        "labels": [chunk.tolist() for chunk in chunks],
+    }
+    return HFDataset.from_dict(payload)

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/dm500_rows.py

@@ -0,0 +1,130 @@
+"""Shared exact-row selection for data-matched experiments."""
+
+from __future__ import annotations
+
+import json
+import os
+import hashlib
+from pathlib import Path
+from typing import Any, Optional
+
+
+def _manifest_canonical_row(value: Any) -> Any:
+    """Canonicalize rows for manifest hash validation.
+
+    Hugging Face datasets may materialize nullable struct fields that were absent
+    when a manifest was generated. SlimOrca's `conversations[*].weight: null` is
+    such a schema-only field and is not consumed by the ABPrune/ReplaceMe text
+    builders. Dropping only null `weight` fields preserves text identity while
+    keeping manifest validation strict for actual content changes.
+    """
+
+    if isinstance(value, dict):
+        return {
+            key: _manifest_canonical_row(child)
+            for key, child in value.items()
+            if not (key == "weight" and child is None)
+        }
+    if isinstance(value, list):
+        return [_manifest_canonical_row(child) for child in value]
+    return value
+
+
+def _json_hash(row: Any) -> str:
+    payload = json.dumps(
+        row,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _canonical_hash(row: Any) -> str:
+    return _json_hash(_manifest_canonical_row(row))
+
+
+def _load_manifest(path: str) -> tuple[list[int], dict[int, str]]:
+    payload = json.loads(Path(path).read_text(encoding="utf-8"))
+    values = payload.get("indices") if isinstance(payload, dict) else payload
+    if not isinstance(values, list) or not values:
+        raise ValueError(f"indices manifest is empty or invalid: {path}")
+    indices = [int(value) for value in values]
+    if len(indices) != len(set(indices)) or min(indices) < 0:
+        raise ValueError(f"indices manifest has duplicates or negative values: {path}")
+    expected_hashes: dict[int, str] = {}
+    if isinstance(payload, dict):
+        records = payload.get("records")
+        if isinstance(records, list):
+            for record in records:
+                if not isinstance(record, dict):
+                    continue
+                raw_index = record.get("raw_index")
+                content_sha256 = record.get("content_sha256")
+                if raw_index is None or not content_sha256:
+                    continue
+                expected_hashes[int(raw_index)] = str(content_sha256)
+    return indices, expected_hashes
+
+
+def _configured_path(manifest_env_var: str) -> str:
+    path = os.getenv(manifest_env_var, "").strip()
+    if not path and manifest_env_var != "ABPRUNE_DATA_INDICES_FILE":
+        path = os.getenv("ABPRUNE_DATA_INDICES_FILE", "").strip()
+    return path
+
+
+def configured_indices(
+    manifest_env_var: str = "ABPRUNE_DATA_INDICES_FILE",
+) -> Optional[list[int]]:
+    path = _configured_path(manifest_env_var)
+    if not path:
+        return None
+    return _load_manifest(path)[0]
+
+
+def select_rows_from_manifest(dataset, manifest_path: str, target: int = 0):
+    indices, expected_hashes = _load_manifest(manifest_path)
+    if target > 0:
+        if target > len(indices):
+            raise ValueError(
+                f"requested {target} rows but manifest contains {len(indices)}"
+            )
+        indices = indices[:target]
+    if hasattr(dataset, "__len__") and indices and max(indices) >= len(dataset):
+        raise ValueError(
+            f"manifest index {max(indices)} exceeds dataset length {len(dataset)}"
+        )
+    if not hasattr(dataset, "select"):
+        raise TypeError("exact DM500 row selection requires a dataset.select implementation")
+    selected = dataset.select(indices)
+    if expected_hashes:
+        for raw_index, row in zip(indices, selected):
+            expected = expected_hashes.get(raw_index)
+            if expected is None:
+                continue
+            raw_actual = _json_hash(row)
+            canonical_actual = _canonical_hash(row)
+            if expected not in {raw_actual, canonical_actual}:
+                raise ValueError(
+                    "manifest content hash mismatch for raw_index "
+                    f"{raw_index}: expected {expected}, got raw={raw_actual}, "
+                    f"canonical={canonical_actual}"
+                )
+    return selected
+
+
+def select_exact_rows(
+    dataset,
+    target: int = 0,
+    manifest_env_var: str = "ABPRUNE_DATA_INDICES_FILE",
+):
+    path = _configured_path(manifest_env_var)
+    if not path:
+        return None
+    return select_rows_from_manifest(dataset, path, target=target)
+
+
+def dataset_revision_kwargs() -> dict[str, str]:
+    revision = os.getenv("ABPRUNE_DATASET_REVISION", "").strip()
+    return {"revision": revision} if revision else {}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/eval_llama31_8b_12bench.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Evaluate the lm-eval portion of the requested Llama benchmark suite.
+
+RACE-H/M, C3, CMNLI, and CHID are evaluated with their canonical OpenCompass
+PPL task definitions by the companion launcher.  This script handles the
+remaining eight tasks plus full zero-shot MMLU and CMMLU.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+
+TASKS = (
+    "piqa",
+    "winogrande",
+    "hellaswag",
+    "arc_challenge",
+    "arc_easy",
+    "openbookqa",
+    "sciq",
+    "mmlu",
+    "cmmlu",
+)
+
+# Use normalized accuracy where the standard harness exposes it.  The
+# extraction code falls back to plain accuracy for tasks/versions without it.
+PREFERRED_METRICS = {
+    "piqa": "acc_norm,none",
+    "hellaswag": "acc_norm,none",
+    "arc_challenge": "acc_norm,none",
+    "arc_easy": "acc_norm,none",
+    "openbookqa": "acc_norm,none",
+    "sciq": "acc_norm,none",
+}
+
+
+def _score(task: str, result: dict[str, Any]) -> tuple[str, float]:
+    preferred = PREFERRED_METRICS.get(task, "acc,none")
+    candidates = (preferred, "acc_norm,none", "acc,none")
+    for metric in candidates:
+        value = result.get(metric)
+        if value is not None:
+            return metric, float(value)
+    available = sorted(key for key in result if "," in key and not key.endswith("_stderr,none"))
+    raise KeyError(f"No supported accuracy metric for {task}; available={available}")
+
+
+def _load_model(args: argparse.Namespace):
+    if args.compact_stage is None:
+        model = AutoModelForCausalLM.from_pretrained(
+            args.model,
+            revision=args.revision,
+            torch_dtype=torch.bfloat16,
+            attn_implementation="eager",
+            local_files_only=args.local_files_only,
+        ).cuda().eval()
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.model,
+            revision=args.revision,
+            local_files_only=args.local_files_only,
+        )
+        return model, tokenizer
+
+    if args.cycle is None or args.anchor is None:
+        raise ValueError("--compact-stage requires --cycle and --anchor")
+    from fusegpt.abprune_stagewise_geometry import load_compact_model
+
+    model = load_compact_model(
+        args.model,
+        args.compact_stage,
+        cycle=args.cycle,
+        anchor=args.anchor,
+        dtype=torch.bfloat16,
+        device=torch.device("cuda"),
+        attn="eager",
+        revision=args.revision,
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.model, revision=args.revision, local_files_only=args.local_files_only)
+    return model, tokenizer
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--revision", default=None)
+    parser.add_argument("--local-files-only", action="store_true")
+    parser.add_argument("--compact-stage", type=Path, default=None)
+    parser.add_argument("--cycle", type=int, default=None)
+    parser.add_argument("--anchor", type=int, default=None)
+    parser.add_argument("--batch-size", default="auto:4")
+    parser.add_argument("--limit", type=float, default=None)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--dataset-cache", type=Path, default=None)
+    parser.add_argument("--tasks", nargs="+", choices=TASKS, default=list(TASKS),
+                        help="Evaluate a subset without repeating already scored tasks")
+    args = parser.parse_args()
+    if len(set(args.tasks)) != len(args.tasks):
+        parser.error("--tasks must not contain duplicates")
+
+    # CMMLU is still distributed through a Hugging Face dataset loading
+    # script.  Opt in explicitly so non-interactive experiment jobs do not
+    # stop at the datasets trust prompt.
+    os.environ.setdefault("HF_DATASETS_TRUST_REMOTE_CODE", "1")
+
+    from lm_eval import evaluator
+    from lm_eval.models.huggingface import HFLM
+
+    if args.dataset_cache is not None:
+        from prepare_lmeval9_local_cache import install_local_loader
+        install_local_loader(args.dataset_cache)
+
+    model, tokenizer = _load_model(args)
+    model.config.use_cache = False
+    if getattr(model, "generation_config", None) is not None:
+        model.generation_config.use_cache = False
+    for layer_idx, layer in enumerate(model.model.layers):
+        if hasattr(layer, "self_attn") and hasattr(layer.self_attn, "layer_idx"):
+            layer.self_attn.layer_idx = layer_idx
+
+    lm = HFLM(
+        pretrained=model,
+        tokenizer=tokenizer,
+        backend="causal",
+        batch_size=args.batch_size,
+    )
+    raw = evaluator.simple_evaluate(
+        model=lm,
+        tasks=args.tasks,
+        num_fewshot=0,
+        batch_size=args.batch_size,
+        random_seed=0,
+        numpy_random_seed=1234,
+        torch_random_seed=1234,
+        fewshot_random_seed=1234,
+        bootstrap_iters=0,
+        limit=args.limit,
+    )
+
+    scores: dict[str, float] = {}
+    metrics: dict[str, str] = {}
+    for task in args.tasks:
+        source = raw.get("groups", {}) if task in {"mmlu", "cmmlu"} else raw["results"]
+        if task not in source:
+            raise KeyError(
+                f"Requested task {task!r} missing from lm-eval results: "
+                f"results={sorted(raw['results'])}, groups={sorted(raw.get('groups', {}))}"
+            )
+        metric, value = _score(task, source[task])
+        metrics[task] = metric
+        scores[task] = value
+
+    report = {
+        "model": args.model,
+        "revision": args.revision,
+        "compact_stage": str(args.compact_stage) if args.compact_stage else None,
+        "cycle": args.cycle,
+        "anchor": args.anchor,
+        "tasks": args.tasks,
+        "num_fewshot": 0,
+        "batch_size": args.batch_size,
+        "limit": args.limit,
+        "dataset_cache": str(args.dataset_cache) if args.dataset_cache else None,
+        "preferred_metrics": metrics,
+        "task_scores": scores,
+        "macro_mean_all_rows": sum(scores.values()) / len(scores),
+        "lm_eval_results": raw["results"],
+        "lm_eval_groups": raw.get("groups"),
+        "lm_eval_versions": raw.get("versions"),
+        "lm_eval_config": raw.get("config"),
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(
+        json.dumps(report, indent=2, ensure_ascii=False, default=str) + "\n",
+        encoding="utf-8",
+    )
+    print(
+        json.dumps(
+            {"task_scores": scores, "macro_mean_all_rows": report["macro_mean_all_rows"]},
+            indent=2,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/eval_llama31_fit_ablation_one.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+set -euo pipefail
+project="$1"; root="$2"; model="$3"; data="$4"; python="$5"
+anchor="$6"; cycles="$7"; gpu="$8"
+stage="$root/compact/stage_$(printf '%02d' "$cycles")"
+export HF_HOME=/workspace/.hf_home HF_TOKEN_PATH=/root/.cache/huggingface/token
+export HF_DATASETS_CACHE=/workspace/.hf_datasets36 HF_DATASETS_TRUST_REMOTE_CODE=1
+export TOKENIZERS_PARALLELISM=false PYTHONUNBUFFERED=1 PYTHONPATH="$project/src"
+revision="${MODEL_REVISION:-49e3418fbbbca6ecbdf9608b4d22e5a407081db4}"
+if [[ -n "${LMEVAL_LOCAL_CACHE:-}" ]]; then
+  export HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 TRANSFORMERS_OFFLINE=1
+  [[ -d "$model" ]] || { echo 'Offline bench requires a local model directory'; exit 1; }
+  "$python" "$project/scripts/prepare_lmeval9_local_cache.py" "$LMEVAL_LOCAL_CACHE" --validate-local
+  for file in race/test/high.jsonl race/test/middle.jsonl CLUE/C3/dev_0.json CLUE/cmnli/cmnli_public/dev.json FewCLUE/chid/dev_few_all.json; do
+    [[ -s "$data/$file" ]] || { echo "Offline OpenCompass input missing: $file"; exit 1; }
+  done
+  echo 'STRICT_OFFLINE_BENCH_PREFLIGHT_OK'
+fi
+opencompass_gpu="$gpu"; lmeval_gpu="${9:-$gpu}"
+if [[ -f "$root/eval/gpu_assignment.json" ]]; then
+  read -r opencompass_gpu lmeval_gpu < <("$python" - "$root/eval/gpu_assignment.json" <<'PY'
+import json, sys
+assignment = json.load(open(sys.argv[1]))
+values = [assignment[key] for key in ("opencompass_gpu", "lmeval_gpu")]
+assert all(type(value) is int and value >= 0 for value in values)
+print(*values)
+PY
+  )
+fi
+run_opencompass() {
+  [[ -f "$root/eval/final_opencompass5.json" ]] && return 0
+  CUDA_VISIBLE_DEVICES="$opencompass_gpu" "$python" "$project/scripts/eval_opencompass_ppl_fast.py" \
+    --model "$model" --revision "$revision" --tokenizer "$model" \
+    --compact-stage "$stage" --cycle "$cycles" --anchor "$anchor" \
+    --data-root "$data" --max-batch 32 --token-budget 8192 \
+    --output "$root/eval/final_opencompass5.json"
+}
+run_lmeval() {
+  [[ -f "$root/eval/final_lmeval9.json" ]] && return 0
+  local cache_args=()
+  if [[ -n "${LMEVAL_LOCAL_CACHE:-}" ]]; then
+    [[ -f "$LMEVAL_LOCAL_CACHE/manifest.json" ]] || return 1
+    cache_args=(--dataset-cache "$LMEVAL_LOCAL_CACHE" --local-files-only)
+    export HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1
+  fi
+  CUDA_VISIBLE_DEVICES="$lmeval_gpu" "$python" "$project/scripts/eval_llama31_8b_12bench.py" \
+    --model "$model" --revision "$revision" --compact-stage "$stage" \
+    --cycle "$cycles" --anchor "$anchor" --batch-size auto:4 \
+    --output "$root/eval/final_lmeval9.json" "${cache_args[@]}"
+}
+if [[ "$opencompass_gpu" != "$lmeval_gpu" ]]; then
+  echo "Parallel evaluation: OpenCompass GPU=$opencompass_gpu; lm-eval GPU=$lmeval_gpu"
+  run_opencompass >> "$root/logs/eval_opencompass.log" 2>&1 & oc_pid=$!
+  run_lmeval >> "$root/logs/eval_lmeval.log" 2>&1 & lm_pid=$!
+  status=0
+  wait "$oc_pid" || status=1
+  wait "$lm_pid" || status=1
+  if ((status)); then exit 1; fi
+else
+  run_opencompass >> "$root/logs/eval14.log" 2>&1
+  run_lmeval >> "$root/logs/eval14.log" 2>&1
+fi
+"$python" "$project/scripts/aggregate_transport_rho_fit_14bench.py" "$root"

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/eval_opencompass_ppl_fast.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""Fast, equivalent evaluator for selected OpenCompass zero-shot PPL tasks.
+
+The prompts, labels, split choices, full-prompt mean-CE scoring, and lowest-PPL
+decision rule mirror OpenCompass 0.5.4's canonical configs for RACE, C3,
+CMNLI, and CHID.  Unlike the stock runner, this evaluator disables KV cache
+and length-batches all choices, which matters substantially on 40 GB GPUs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Iterable
+
+import torch
+import torch.nn.functional as F
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+
+def read_jsonl(path: Path) -> Iterable[dict]:
+    with path.open("r", encoding="utf-8") as stream:
+        for line in stream:
+            yield json.loads(line)
+
+
+def race(path: Path) -> tuple[list[list[str]], list[int]]:
+    prompts, golds = [], []
+    for row in read_jsonl(path):
+        human = (
+            "Read the article, and answer the question by replying A, B, C or D.\n\n"
+            f"Article:\n{row['article']}\n\nQ: {row['question']}\n\n"
+            f"A. {row['options'][0]}\nB. {row['options'][1]}\n"
+            f"C. {row['options'][2]}\nD. {row['options'][3]}"
+        )
+        prompts.append([human + "\n" + f"A: {answer}" for answer in "ABCD"])
+        golds.append("ABCD".index(row["answer"]))
+    return prompts, golds
+
+
+def c3(path: Path) -> tuple[list[list[str]], list[int]]:
+    prompts, golds = [], []
+    rows = json.loads(path.read_text(encoding="utf-8"))
+    for row in rows:
+        content = " ".join("".join(paragraph) for paragraph in row[0])
+        for question in row[1]:
+            choices = list(question["choice"])
+            golds.append(choices.index(question["answer"]))
+            while len(choices) < 4:
+                choices.append(choices[0])
+            human = f"文章：{content}\n问题：{question['question']}"
+            prompts.append([human + "\n" + f"答案：{choice}" for choice in choices[:4]])
+    return prompts, golds
+
+
+def cmnli(path: Path) -> tuple[list[list[str]], list[int]]:
+    labels = ("contradiction", "entailment", "neutral")
+    verbalizers = ("矛盾", "蕴含", "无关")
+    prompts, golds = [], []
+    for row in read_jsonl(path):
+        if row["label"] == "-":
+            continue
+        human = (
+            f"语句一：“{row['sentence1']}”\n语句二：“{row['sentence2']}”\n"
+            "请问这两句话是什么关系？"
+        )
+        prompts.append([human + "\n" + word for word in verbalizers])
+        golds.append(labels.index(row["label"]))
+    return prompts, golds
+
+
+def chid(path: Path) -> tuple[list[list[str]], list[int]]:
+    prompts, golds = [], []
+    for row in read_jsonl(path):
+        candidates = [row["content"].replace("#idiom#", candidate) for candidate in row["candidates"]]
+        prompts.append([
+            f"以下句子是否通顺？\n{content}\n这个句子是通顺的。" for content in candidates
+        ])
+        golds.append(int(row["answer"]))
+    return prompts, golds
+
+
+def score_task(model, tokenizer, choices: list[list[str]], golds: list[int], max_batch: int,
+               token_budget: int) -> dict:
+    flat = [(sample_idx, choice_idx, prompt)
+            for sample_idx, row in enumerate(choices)
+            for choice_idx, prompt in enumerate(row)]
+    encoded = tokenizer(
+        [item[2] for item in flat],
+        add_special_tokens=True,
+        padding=False,
+        truncation=True,
+        max_length=model.config.max_position_embeddings,
+    )["input_ids"]
+    order = sorted(range(len(flat)), key=lambda idx: len(encoded[idx]), reverse=True)
+    losses = [0.0] * len(flat)
+    cursor = 0
+    while cursor < len(order):
+        longest = len(encoded[order[cursor]])
+        batch_size = min(max_batch, max(1, token_budget // longest), len(order) - cursor)
+        while True:
+            batch_indices = order[cursor:cursor + batch_size]
+            max_len = max(len(encoded[idx]) for idx in batch_indices)
+            input_ids = torch.full(
+                (batch_size, max_len), tokenizer.pad_token_id, dtype=torch.long, device="cuda"
+            )
+            attention = torch.zeros((batch_size, max_len), dtype=torch.long, device="cuda")
+            for row_idx, flat_idx in enumerate(batch_indices):
+                values = torch.tensor(encoded[flat_idx], dtype=torch.long, device="cuda")
+                input_ids[row_idx, : len(values)] = values
+                attention[row_idx, : len(values)] = 1
+            try:
+                with torch.inference_mode():
+                    logits = model(input_ids=input_ids, attention_mask=attention, use_cache=False).logits
+                    token_loss = F.cross_entropy(
+                        logits[:, :-1].float().reshape(-1, logits.shape[-1]),
+                        input_ids[:, 1:].reshape(-1),
+                        reduction="none",
+                    ).view(batch_size, -1)
+                    # OpenCompass divides by the number of non-padding input
+                    # tokens (including BOS), while scoring shifted labels.
+                    sequence_loss = (
+                        token_loss * attention[:, 1:]
+                    ).sum(dim=1) / attention.sum(dim=1)
+                break
+            except torch.OutOfMemoryError:
+                del input_ids, attention
+                torch.cuda.empty_cache()
+                if batch_size == 1:
+                    raise
+                batch_size = max(1, batch_size // 2)
+        for flat_idx, value in zip(batch_indices, sequence_loss.tolist()):
+            losses[flat_idx] = value
+        cursor += batch_size
+        if cursor % 1000 < batch_size or cursor == len(order):
+            print(f"choices={cursor}/{len(order)}", flush=True)
+
+    score_rows = [[0.0] * len(row) for row in choices]
+    for flat_idx, (sample_idx, choice_idx, _) in enumerate(flat):
+        score_rows[sample_idx][choice_idx] = losses[flat_idx]
+    predictions = [min(range(len(row)), key=row.__getitem__) for row in score_rows]
+    correct = sum(prediction == gold for prediction, gold in zip(predictions, golds))
+    return {
+        "accuracy": correct / len(golds),
+        "correct": correct,
+        "samples": len(golds),
+        "choices": len(flat),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--revision", default=None)
+    parser.add_argument("--tokenizer", required=True)
+    parser.add_argument("--compact-stage", type=Path, default=None)
+    parser.add_argument("--cycle", type=int, default=None)
+    parser.add_argument("--anchor", type=int, default=None)
+    parser.add_argument("--data-root", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--max-batch", type=int, default=32)
+    parser.add_argument("--token-budget", type=int, default=8192)
+    parser.add_argument("--limit", type=int, default=None)
+    args = parser.parse_args()
+
+    tokenizer = AutoTokenizer.from_pretrained(args.tokenizer, local_files_only=True)
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+    tokenizer.padding_side = "right"
+    if args.compact_stage is None:
+        model = AutoModelForCausalLM.from_pretrained(
+            args.model,
+            revision=args.revision,
+            torch_dtype=torch.bfloat16,
+            attn_implementation="sdpa",
+            local_files_only=True,
+        ).cuda().eval()
+    else:
+        if args.cycle is None or args.anchor is None:
+            raise ValueError("--compact-stage requires --cycle and --anchor")
+        from fusegpt.abprune_stagewise_geometry import load_compact_model
+
+        model = load_compact_model(
+            args.model,
+            args.compact_stage,
+            cycle=args.cycle,
+            anchor=args.anchor,
+            dtype=torch.bfloat16,
+            device=torch.device("cuda"),
+            attn="sdpa",
+            revision=args.revision,
+        )
+    model.config.use_cache = False
+
+    datasets = {
+        "race-middle": race(args.data_root / "race/test/middle.jsonl"),
+        "race-high": race(args.data_root / "race/test/high.jsonl"),
+        "C3": c3(args.data_root / "CLUE/C3/dev_0.json"),
+        "cmnli": cmnli(args.data_root / "CLUE/cmnli/cmnli_public/dev.json"),
+        "chid-dev": chid(args.data_root / "FewCLUE/chid/dev_few_all.json"),
+    }
+    results = {}
+    for name, (choices, golds) in datasets.items():
+        if args.limit is not None:
+            choices, golds = choices[: args.limit], golds[: args.limit]
+        print(f"task={name} samples={len(golds)}", flush=True)
+        results[name] = score_task(
+            model, tokenizer, choices, golds, args.max_batch, args.token_budget
+        )
+        print(json.dumps({name: results[name]}, ensure_ascii=False), flush=True)
+
+    report = {
+        "model": args.model,
+        "revision": args.revision,
+        "compact_stage": str(args.compact_stage) if args.compact_stage else None,
+        "cycle": args.cycle,
+        "anchor": args.anchor,
+        "tokenizer": args.tokenizer,
+        "protocol": "OpenCompass 0.5.4 canonical PPL prompts; full-prompt mean CE; lowest PPL",
+        "max_batch": args.max_batch,
+        "token_budget": args.token_budget,
+        "limit": args.limit,
+        "results": results,
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/evaluate_abprune_compact_ppl.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""Evaluate an unscaled or residual-scaled compact ABPrune checkpoint."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from contextlib import ExitStack
+from pathlib import Path
+import sys
+
+from offline_eval_policy import apply_run_offline_policy
+
+OFFLINE_POLICY = apply_run_offline_policy(sys.argv)
+
+import torch
+
+from evaluate_hchc_wikitext2_ppl import evaluate_perplexity, packed_wikitext_tokens
+from fusegpt.abprune_residual_scale import residual_scale_hook
+from fusegpt.abprune_compact import compact_scale_targets, read_compact_metadata
+from fusegpt.abprune_stagewise_geometry import load_compact_model
+from fusegpt.hadamard_channel_fusion import linear_patch_hook
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--revision", required=True)
+    parser.add_argument("--compact-stage", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--anchor", type=int, default=None)
+    parser.add_argument("--cycles", type=int, required=True)
+    parser.add_argument("--original-layers", type=int, required=True)
+    parser.add_argument("--seq-len", type=int, default=2048)
+    parser.add_argument("--batch-size", type=int, default=4)
+    parser.add_argument("--device", default="cuda")
+    parser.add_argument("--apply-post-merge-scale", action="store_true")
+    parser.add_argument("--linear-patch", type=Path, default=None)
+    args = parser.parse_args()
+
+    # Long training supervisors may be asked to stop after model construction.
+    # A run-local marker makes that request durable without killing training.
+    run_root = args.output.parent.parent
+    if (run_root / "DEFER_EVAL").exists():
+        print(f"[eval] deferred by {run_root / 'DEFER_EVAL'}", flush=True)
+        raise SystemExit(75)
+
+    device = torch.device(args.device)
+    model = load_compact_model(
+        args.model,
+        args.compact_stage,
+        cycle=args.cycles,
+        anchor=args.anchor,
+        dtype=torch.bfloat16,
+        device=device,
+        attn="eager",
+        revision=args.revision,
+    )
+    model.eval()
+    expected_depth = args.original_layers - args.cycles
+    if len(model.model.layers) != expected_depth:
+        raise RuntimeError(
+            f"Unexpected decoder depth: {len(model.model.layers)} != {expected_depth}"
+        )
+
+    from transformers import AutoTokenizer
+
+    if OFFLINE_POLICY and not Path(args.model).is_dir():
+        raise ValueError('Strict offline PPL requires a local model directory')
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.model, revision=args.revision, local_files_only=bool(OFFLINE_POLICY))
+    applied_scales = []
+    scale_stack = ExitStack()
+    linear_patch = None
+    if args.apply_post_merge_scale:
+        metadata = read_compact_metadata(args.compact_stage)
+        targets = compact_scale_targets(metadata)
+        if not targets:
+            raise RuntimeError(
+                "--apply-post-merge-scale requires enabled residual scale metadata"
+            )
+        for target in targets:
+            stored_scale = target["scale"]["cumulative_gamma"]
+            applied = (
+                torch.tensor(stored_scale, device=device, dtype=torch.float32)
+                if isinstance(stored_scale, list)
+                else float(stored_scale)
+            )
+            scale_stack.enter_context(
+                residual_scale_hook(model, int(target["student_index"]), applied)
+            )
+            applied_scales.append(
+                {
+                    "original_layer": int(target["original_layer"]),
+                    "student_index": int(target["student_index"]),
+                    "value": applied,
+                }
+            )
+    if args.linear_patch is not None:
+        linear_patch = json.loads(args.linear_patch.read_text(encoding="utf-8"))
+        patch_scale = torch.tensor(
+            linear_patch["scale"], device=device, dtype=torch.float32
+        )
+        patch_anchor = int(linear_patch["anchor_student_index"])
+        scale_stack.enter_context(
+            linear_patch_hook(
+                model.model.layers[patch_anchor],
+                patch_scale,
+                hadamard=linear_patch["mode"] == "hadamard",
+            )
+        )
+
+    with scale_stack:
+        tokens = packed_wikitext_tokens(
+            tokenizer, "test", dataset_cache=(
+                Path(OFFLINE_POLICY['wikitext_cache']) if OFFLINE_POLICY else None))
+        metrics = evaluate_perplexity(
+            model=model,
+            tokens=tokens,
+            sequence_length=args.seq_len,
+            batch_size=args.batch_size,
+        )
+
+    report = {
+        "model": args.model,
+        "revision": args.revision,
+        "compact_stage": str(args.compact_stage),
+        "dataset": "Salesforce/wikitext:wikitext-2-raw-v1:test",
+        "offline_policy": OFFLINE_POLICY,
+        "protocol": (
+            "HCHC experiment.py: filter empty rows, join with double newline, "
+            "then tokenize the complete stream once"
+        ),
+        "sequence_length": args.seq_len,
+        "batch_size": args.batch_size,
+        "dtype": "bfloat16",
+        "metrics": metrics,
+        "anchor": args.anchor,
+        "cycles": args.cycles,
+        "original_layers": args.original_layers,
+        "decoder_layers": len(model.model.layers),
+        "post_merge_residual_scale": (
+            applied_scales[0]["value"].tolist()
+            if len(applied_scales) == 1
+            and torch.is_tensor(applied_scales[0]["value"])
+            else (
+                applied_scales[0]["value"]
+                if len(applied_scales) == 1
+                else None
+            )
+        ),
+        "post_merge_residual_scales": [
+            {
+                "original_layer": item["original_layer"],
+                "student_index": item["student_index"],
+                "parameterization": (
+                    "vector" if torch.is_tensor(item["value"]) else "scalar"
+                ),
+                "value": (
+                    item["value"].tolist()
+                    if torch.is_tensor(item["value"])
+                    else item["value"]
+                ),
+            }
+            for item in applied_scales
+        ],
+        "parameterization": (
+            "X_interface <- X_interface H D H.T"
+            if linear_patch and linear_patch["mode"] == "hadamard"
+            else (
+                "X_interface <- X_interface D"
+                if linear_patch
+                else (
+                    "h_out = h_in + gamma * (block(h_in) - h_in)"
+                    if applied_scales else "unscaled compact ABPrune"
+                )
+            )
+        ),
+        "linear_patch": linear_patch,
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(report, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/evaluate_hchc_wikitext2_ppl.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Evaluate a saved causal LM with the HCHC WikiText-2 PPL protocol."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+import torch
+from datasets import load_dataset, load_from_disk
+
+
+def primary(output: Any) -> torch.Tensor:
+    if torch.is_tensor(output):
+        return output
+    if isinstance(output, (tuple, list)) and output and torch.is_tensor(output[0]):
+        return output[0]
+    raise TypeError(f"Unsupported decoder-layer output type: {type(output)!r}")
+
+
+def replace_primary(output: Any, hidden: torch.Tensor) -> Any:
+    if torch.is_tensor(output):
+        return hidden
+    if isinstance(output, tuple):
+        return (hidden, *output[1:])
+    if isinstance(output, list):
+        return [hidden, *output[1:]]
+    raise TypeError(f"Unsupported decoder-layer output type: {type(output)!r}")
+
+
+def register_residual_scale_hook(layer, gamma: float):
+    """Install h_out = h_in + gamma * (block(h_in) - h_in)."""
+    scale = torch.tensor(gamma, device=next(layer.parameters()).device)
+
+    def hook(_module, inputs, output):
+        if not inputs or not torch.is_tensor(inputs[0]):
+            raise RuntimeError("Could not capture decoder-layer residual input")
+        layer_input = inputs[0]
+        corrected = layer_input + scale * (primary(output) - layer_input)
+        return replace_primary(output, corrected)
+
+    return layer.register_forward_hook(hook)
+
+
+def packed_wikitext_tokens(tokenizer, split: str, *, dataset_cache: Path | None = None) -> torch.Tensor:
+    """Reproduce the canonical HCHC WikiText-2 packing protocol."""
+    if dataset_cache is not None:
+        dataset = load_from_disk(str(dataset_cache))[split]
+    else:
+        dataset = load_dataset(
+            "Salesforce/wikitext", "wikitext-2-raw-v1", split=split
+        )
+    text = "\n\n".join(row for row in dataset["text"] if row.strip())
+    return tokenizer(
+        text, add_special_tokens=False, return_tensors="pt"
+    ).input_ids[0]
+
+
+@torch.no_grad()
+def evaluate_perplexity(
+    model,
+    tokens: torch.Tensor,
+    sequence_length: int,
+    batch_size: int,
+) -> dict[str, float | int]:
+    num_sequences = tokens.numel() // sequence_length
+    ids = tokens[: num_sequences * sequence_length].view(num_sequences, sequence_length)
+    total_nll = 0.0
+    total_predicted_tokens = 0
+    model.eval()
+    for start in range(0, num_sequences, batch_size):
+        batch = ids[start : start + batch_size].to("cuda")
+        output = model(input_ids=batch, labels=batch, use_cache=False)
+        predicted = batch.shape[0] * (batch.shape[1] - 1)
+        total_nll += output.loss.float().item() * predicted
+        total_predicted_tokens += predicted
+    mean_nll = total_nll / total_predicted_tokens
+    return {
+        "nll": mean_nll,
+        "perplexity": math.exp(mean_nll),
+        "tokens": total_predicted_tokens,
+        "sequences": num_sequences,
+        "source_tokens": int(tokens.numel()),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--sequence-length", type=int, default=2048)
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--residual-anchor", type=int)
+    parser.add_argument("--residual-gamma", type=float)
+    args = parser.parse_args()
+
+    if (args.residual_anchor is None) != (args.residual_gamma is None):
+        parser.error("--residual-anchor and --residual-gamma must be supplied together")
+
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    tokenizer = AutoTokenizer.from_pretrained(args.model, local_files_only=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        args.model,
+        torch_dtype=torch.bfloat16,
+        local_files_only=True,
+        low_cpu_mem_usage=True,
+        attn_implementation="sdpa",
+    ).to("cuda")
+    model.config.use_cache = False
+
+    handle = None
+    if args.residual_gamma is not None:
+        if args.residual_anchor >= len(model.model.layers):
+            raise ValueError(
+                f"Residual anchor {args.residual_anchor} is outside decoder depth "
+                f"{len(model.model.layers)}"
+            )
+        handle = register_residual_scale_hook(
+            model.model.layers[args.residual_anchor], args.residual_gamma
+        )
+
+    tokens = packed_wikitext_tokens(tokenizer, "test")
+    try:
+        metrics = evaluate_perplexity(
+            model, tokens, args.sequence_length, args.batch_size
+        )
+    finally:
+        if handle is not None:
+            handle.remove()
+
+    report = {
+        "model": str(args.model),
+        "dataset": "Salesforce/wikitext:wikitext-2-raw-v1:test",
+        "protocol": "HCHC experiment.py: non-empty rows joined with double newline before one-shot tokenization",
+        "sequence_length": args.sequence_length,
+        "batch_size": args.batch_size,
+        "dtype": "bfloat16",
+        "residual_anchor": args.residual_anchor,
+        "residual_gamma": args.residual_gamma,
+        "metrics": metrics,
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(report, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/fit_ablation_mka.py

@@ -0,0 +1,482 @@
+"""Corrected MKA variant: adjacent NPIB selection, upstream lambda, real fusion.
+
+Not an exact reproduction of the paper: use sequence-level pooled activations,
+recompute geometry after every merge, and resolve NPIB ties back-to-front.
+The seven projection weights are fused; residual and Q/K norms stay at anchor.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import random
+from collections.abc import Callable, Iterable, Sequence
+from dataclasses import asdict, dataclass
+
+import numpy as np
+import torch
+from scipy.linalg import eigh
+from scipy.spatial.distance import pdist, squareform
+from sklearn.feature_selection import mutual_info_regression
+from sklearn.neighbors import NearestNeighbors
+from torch import Tensor, nn
+
+PROJECTION_WEIGHTS = (
+    "mlp.down_proj.weight",
+    "mlp.up_proj.weight",
+    "mlp.gate_proj.weight",
+    "self_attn.k_proj.weight",
+    "self_attn.o_proj.weight",
+    "self_attn.q_proj.weight",
+    "self_attn.v_proj.weight",
+)
+UPSTREAM = "https://github.com/SempraETY/Pruning-via-Merging"
+UPSTREAM_COMMIT = "3b60b002a0963266e2f4ca78f133b4e091bc607a"
+
+
+@dataclass(frozen=True)
+class GeometryConfig:
+    sigma: float = 8.0
+    alpha: float = 0.5
+    dimensions: int = 2
+    mi_neighbors: int = 5
+    entropy_neighbors: int = 50
+    beta: float = 1.0
+    seed: int = 0
+    pooling: str = "mean"
+
+    def validate(self) -> None:
+        if not math.isfinite(self.sigma) or self.sigma <= 0:
+            raise ValueError("sigma must be positive and finite")
+        if not math.isfinite(self.alpha) or not 0 <= self.alpha <= 1:
+            raise ValueError("alpha must be finite and in [0, 1]")
+        if self.dimensions < 1 or min(self.mi_neighbors, self.entropy_neighbors) < 1:
+            raise ValueError("dimensions and neighbor counts must be positive")
+        if not math.isfinite(self.beta) or self.beta < 0:
+            raise ValueError("beta must be non-negative and finite")
+        if self.pooling not in {"mean", "last"}:
+            raise ValueError("pooling must be 'mean' or 'last'")
+
+
+def sample_slimpajama(
+    tokenizer,
+    *,
+    samples: int = 100,
+    sequence_length: int = 512,
+    seed: int = 0,
+    revision: str = "b5f90f419b7489cdba26fdbc8c022fcb5562f968",
+    shuffle_buffer: int = 10000,
+    max_documents: int = 100000,
+    documents: Iterable[dict] | None = None,
+) -> tuple[list[dict[str, Tensor]], dict]:
+    """Exactly one random fixed-length, no-BOS window from each distinct document.
+
+    Unlike CoMe's row-packing loader, ``samples`` is the number of sequences.
+    Persist returned IDs and provenance; do not sample again between stages.
+    """
+    if min(samples, sequence_length, shuffle_buffer, max_documents) < 1:
+        raise ValueError("sampling counts, length and buffer must be positive")
+    if documents is None:
+        from datasets import load_dataset
+
+        documents = load_dataset(
+            "DKYoon/SlimPajama-6B", revision=revision, split="train", streaming=True
+        ).shuffle(seed=seed, buffer_size=shuffle_buffer)
+    rng = random.Random(seed)
+    batches, records, seen = [], [], set()
+    iterator = iter(documents)
+    try:
+        for row_index, row in enumerate(iterator):
+            if row_index >= max_documents:
+                break
+            text = row.get("text")
+            if not isinstance(text, str) or not text.strip():
+                continue
+            digest = hashlib.sha256(text.encode("utf-8")).hexdigest()
+            if digest in seen:
+                continue
+            seen.add(digest)
+            ids = tokenizer.encode(text, add_special_tokens=False)
+            if len(ids) < sequence_length:
+                continue
+            start = rng.randrange(len(ids) - sequence_length + 1)
+            tensor = torch.tensor(
+                ids[start : start + sequence_length], dtype=torch.long
+            )[None, :]
+            batches.append(
+                {"input_ids": tensor, "attention_mask": torch.ones_like(tensor)}
+            )
+            records.append(
+                {
+                    "stream_row": row_index,
+                    "document_sha256": digest,
+                    "document_tokens": len(ids),
+                    "window_start": start,
+                }
+            )
+            if len(batches) == samples:
+                break
+    finally:
+        close = getattr(iterator, "close", None)
+        if close is not None:
+            close()
+    if len(batches) != samples:
+        raise RuntimeError(
+            f"Only found {len(batches)}/{samples} distinct sufficiently long documents"
+        )
+    checksum = hashlib.sha256()
+    for batch in batches:
+        checksum.update(batch["input_ids"].numpy().astype("<i8").tobytes())
+    metadata = {
+        "dataset": "DKYoon/SlimPajama-6B",
+        "revision": revision,
+        "split": "train",
+        "samples": samples,
+        "sequence_length": sequence_length,
+        "seed": seed,
+        "shuffle_buffer": shuffle_buffer,
+        "add_special_tokens": False,
+        "sampling": "one random window per distinct document",
+        "input_ids_sha256": checksum.hexdigest(),
+        "records": records,
+    }
+    return batches, metadata
+
+
+@torch.inference_mode()
+def collect_features(
+    model: nn.Module, batches: Sequence[dict[str, Tensor]], *, pooling: str = "mean"
+) -> list[np.ndarray]:
+    """One backbone forward per batch; block hooks avoid hidden-state off-by-one.
+
+    Collect outputs *before* the final backbone norm, including the final block.
+    Pool only valid tokens; activations are CPU float32 after pooling.
+    """
+    if pooling not in {"mean", "last"} or not batches:
+        raise ValueError("valid pooling and nonempty calibration batches are required")
+    layers = model.model.layers
+    features: list[list[Tensor]] = [[] for _ in layers]
+    current_mask: Tensor | None = None
+
+    def hook(index):
+        def capture(module, inputs, output):
+            hidden = output[0] if isinstance(output, (tuple, list)) else output
+            mask = current_mask.to(hidden.device, dtype=torch.bool)
+            if hidden.shape[:2] != mask.shape or (mask.sum(-1) == 0).any():
+                raise ValueError("block output and valid-token mask do not match")
+            if pooling == "mean":
+                value = (hidden.float() * mask[:, :, None]).sum(1) / mask.sum(1)[
+                    :, None
+                ]
+            else:
+                positions = torch.arange(mask.shape[1], device=mask.device)[None, :]
+                last = positions.expand_as(mask).masked_fill(~mask, -1).max(1).values
+                value = hidden[
+                    torch.arange(hidden.shape[0], device=hidden.device), last
+                ].float()
+            if not torch.isfinite(value).all():
+                raise FloatingPointError(f"nonfinite activation in block {index}")
+            features[index].append(value.cpu())
+
+        return capture
+
+    handles = [layer.register_forward_hook(hook(i)) for i, layer in enumerate(layers)]
+    was_training = model.training
+    model.eval()
+    try:
+        device = model.get_input_embeddings().weight.device
+        for batch in batches:
+            prepared = {key: value.to(device) for key, value in batch.items()}
+            current_mask = prepared.get(
+                "attention_mask", torch.ones_like(prepared["input_ids"])
+            )
+            model.model(**prepared, use_cache=False, return_dict=True)
+    finally:
+        for handle in handles:
+            handle.remove()
+        model.train(was_training)
+    expected = sum(batch["input_ids"].shape[0] for batch in batches)
+    arrays = [torch.cat(parts, dim=0).numpy() for parts in features]
+    if any(array.shape[0] != expected for array in arrays):
+        raise RuntimeError("not all calibration examples reached each decoder block")
+    return arrays
+
+
+def diffusion_embedding(
+    features: np.ndarray, config: GeometryConfig
+) -> tuple[np.ndarray, dict]:
+    """Correctly shaped sample-by-sample diffusion kernel, following upstream SVD geometry."""
+    config.validate()
+    x = np.asarray(features, dtype=np.float64)
+    if x.ndim != 2 or not np.isfinite(x).all() or len(x) <= config.dimensions + 1:
+        raise ValueError(
+            "features must be finite [samples, features], samples > dimensions + 1"
+        )
+    distance = squareform(pdist(x, metric="euclidean"))
+    if distance.max() <= np.finfo(float).eps:
+        raise ValueError(
+            "constant calibration features: cannot estimate manifold geometry"
+        )
+    kernel = np.exp(-np.sqrt(distance / config.sigma))
+    p = kernel.sum(0)
+    normalized = kernel / np.outer(p, p) ** config.alpha
+    v = np.sqrt(normalized.sum(0))
+    operator = normalized / np.outer(v, v)
+    condition = float(np.linalg.cond(operator))
+    regularization = 1e-6 if not math.isfinite(condition) or condition > 1e12 else 0.0
+    if regularization:
+        operator += regularization * np.eye(len(x))
+    values, vectors = eigh(
+        operator, subset_by_index=(len(x) - config.dimensions - 1, len(x) - 1)
+    )
+    values, vectors = values[::-1], vectors[:, ::-1]
+    # Fix arbitrary eigenvector signs; the leading vector of this positive kernel is positive.
+    for dim in range(vectors.shape[1]):
+        if vectors[np.argmax(np.abs(vectors[:, dim])), dim] < 0:
+            vectors[:, dim] *= -1
+    if np.any(np.abs(vectors[:, 0]) < 1e-12):
+        raise FloatingPointError(
+            "diffusion normalization has a near-zero leading eigenvector"
+        )
+    embedding = vectors[:, 1:] / vectors[:, :1]
+    if not np.isfinite(embedding).all():
+        raise FloatingPointError("nonfinite diffusion embedding")
+    # Upstream uses per-axis rank normalization before its KNN estimators.
+    embedding = np.argsort(
+        np.argsort(embedding, axis=0, kind="stable"), axis=0, kind="stable"
+    ) / len(x)
+    return embedding, {
+        "samples": len(x),
+        "condition_number": condition if math.isfinite(condition) else None,
+        "regularization": regularization,
+        "eigenvalues": values.tolist(),
+    }
+
+
+def entropy_knn(x: np.ndarray, neighbors: int) -> float:
+    """Upstream differential-entropy estimator, evaluated in log space."""
+    n, dimensions = x.shape
+    k = min(neighbors, n - 1)
+    distances = NearestNeighbors(n_neighbors=k + 1).fit(x).kneighbors(x)[0][:, -1]
+    if np.any(distances <= 0) or not np.isfinite(distances).all():
+        raise FloatingPointError(
+            "duplicate/degenerate manifold points in entropy estimator"
+        )
+    return float(math.log(n / k) + dimensions * np.log(distances).mean())
+
+
+def npib_matrix(
+    embeddings: Sequence[np.ndarray], config: GeometryConfig
+) -> tuple[np.ndarray, list[float]]:
+    """Match upstream axis-wise MI average and symmetric sqrt(H_i*H_j) normalization.
+
+    Differential entropies can be negative. Preserve upstream's formula when
+    their product is positive; fail clearly for zero/negative products or NaNs.
+    This estimator is a heuristic, not a guaranteed [0, 1] similarity.
+    """
+    config.validate()
+    if not embeddings or len({x.shape for x in embeddings}) != 1:
+        raise ValueError("embeddings must have identical sample/coordinate shapes")
+    n = len(embeddings[0])
+    if n < 3 or any(not np.isfinite(x).all() for x in embeddings):
+        raise ValueError("need at least three finite manifold points")
+    entropies = [entropy_knn(x, config.entropy_neighbors) for x in embeddings]
+    scores = np.empty((len(embeddings), len(embeddings)), dtype=np.float64)
+    for i, left in enumerate(embeddings):
+        for j in range(i, len(embeddings)):
+            right = embeddings[j]
+            product = entropies[i] * entropies[j]
+            if not math.isfinite(product) or product <= 1e-12:
+                raise FloatingPointError(
+                    f"invalid entropy product at ({i}, {j}): {entropies[i]}, {entropies[j]}"
+                )
+            mi = np.mean(
+                [
+                    np.mean(
+                        mutual_info_regression(
+                            left,
+                            right[:, dim],
+                            n_neighbors=min(config.mi_neighbors, n - 1),
+                            random_state=config.seed,
+                        )
+                    )
+                    for dim in range(right.shape[1])
+                ]
+            )
+            scores[i, j] = scores[j, i] = mi / math.sqrt(product)
+    if not np.isfinite(scores).all():
+        raise FloatingPointError("NPIB contains nonfinite scores")
+    return scores, entropies
+
+
+def upstream_lambda(
+    scores: np.ndarray, left: int, right: int, beta: float = 1.0
+) -> float:
+    """Exactly upstream's sigmoid(beta * row_mean_i / (row_mean_i + row_mean_j))."""
+    means = np.mean(scores[[left, right]], axis=1)
+    total = float(means.sum())
+    if not np.isfinite(means).all() or (means < 0).any() or total <= 1e-12:
+        raise FloatingPointError(
+            "cannot compute upstream lambda from nonpositive/nonfinite row means"
+        )
+    if not math.isfinite(beta) or beta < 0:
+        raise ValueError("beta must be non-negative and finite")
+    value = beta * float(means[0]) / total
+    return 1.0 / (1.0 + math.exp(-value))
+
+
+def select_pair(
+    scores: np.ndarray,
+    *,
+    selection: str = "npib",
+    protected_first: int = 0,
+    protected_last: int = 0,
+) -> int:
+    """Adjacent pairs only; NPIB descending, and deeper pair wins exact ties."""
+    n = len(scores)
+    if scores.shape != (n, n) or not np.isfinite(scores).all():
+        raise ValueError("scores must be a finite square matrix")
+    if min(protected_first, protected_last) < 0:
+        raise ValueError("protected layer counts must be non-negative")
+    candidates = range(protected_first, n - protected_last - 1)
+    if not candidates:
+        raise ValueError("no eligible adjacent pair remains")
+    if selection == "back-to-front":
+        return candidates[-1]
+    if selection != "npib":
+        raise ValueError("selection must be 'npib' or 'back-to-front'")
+    return max(candidates, key=lambda i: (float(scores[i, i + 1]), i))
+
+
+@torch.inference_mode()
+def merge_pair(model: nn.Module, left: int, ratio: float) -> int:
+    """FP32 weighted sum copied into real parameters, then delete the right block."""
+    layers = model.model.layers
+    if (
+        not 0 <= left < len(layers) - 1
+        or not math.isfinite(ratio)
+        or not 0 <= ratio <= 1
+    ):
+        raise ValueError("invalid adjacent pair or merge ratio")
+    destination, source = layers[left], layers[left + 1]
+    pairs = []
+    for name in PROJECTION_WEIGHTS:
+        pairs.append((destination.get_parameter(name), source.get_parameter(name)))
+        # Qwen2.5 has Q/K/V biases. Fuse them with the same coefficient;
+        # Llama and Qwen3 (bias-free projections) retain their existing behavior.
+        module_name = name.rsplit('.', 1)[0]
+        a_bias = getattr(destination.get_submodule(module_name), 'bias', None)
+        b_bias = getattr(source.get_submodule(module_name), 'bias', None)
+        if (a_bias is None) != (b_bias is None):
+            raise ValueError('projection bias presence differs between merge layers')
+        if a_bias is not None:
+            pairs.append((a_bias, b_bias))
+    # Validate all shapes/values/config before any model mutation.
+    if any(a.shape != b.shape for a, b in pairs):
+        raise ValueError("projection shapes differ between merge layers")
+    if any(not torch.isfinite(p).all() for pair in pairs for p in pair):
+        raise FloatingPointError("nonfinite source weight")
+    configs = [model.config, model.model.config]
+    for config in configs:
+        types = getattr(config, "layer_types", None)
+        if types is not None and len(types) != len(layers):
+            raise ValueError("config.layer_types length does not match decoder depth")
+    changed = 0
+    for target, other in pairs:
+        merged = torch.lerp(
+            other.detach().to(target.device, dtype=torch.float32), target.float(), ratio
+        )
+        merged = merged.to(target.dtype)
+        if not torch.isfinite(merged).all():
+            raise FloatingPointError("merge overflow after conversion to model dtype")
+        changed += int(not torch.equal(target, merged))
+        target.copy_(merged)
+    del layers[left + 1]
+    handled = set()
+    for config in configs:
+        if id(config) in handled:
+            continue
+        handled.add(id(config))
+        config.num_hidden_layers = len(layers)
+        if getattr(config, "layer_types", None) is not None:
+            config.layer_types = list(config.layer_types[: left + 1]) + list(
+                config.layer_types[left + 2 :]
+            )
+    for index, layer in enumerate(layers):
+        if hasattr(layer.self_attn, "layer_idx"):
+            layer.self_attn.layer_idx = index
+    return changed
+
+
+def progressive_prune(
+    model: nn.Module,
+    batches: Sequence[dict[str, Tensor]],
+    *,
+    target_layers: int,
+    geometry: GeometryConfig | None = None,
+    selection: str = "npib",
+    protected_first: int = 0,
+    protected_last: int = 0,
+    on_stage: Callable[[nn.Module, dict], None] | None = None,
+) -> list[dict]:
+    """Recompute activations/manifolds/NPIB on fixed data after every accepted merge.
+
+    No threshold or forced fallbacks; stop at the requested exact depth. Repeated
+    merging of a previously merged block is allowed and recorded in its lineage.
+    """
+    geometry = geometry or GeometryConfig()
+    geometry.validate()
+    depth = len(model.model.layers)
+    if min(protected_first, protected_last) < 0 or not 1 <= target_layers <= depth:
+        raise ValueError("invalid target depth or protected counts")
+    if target_layers < protected_first + protected_last + 1:
+        raise ValueError("target depth would remove protected layers")
+    if selection not in {"npib", "back-to-front"}:
+        raise ValueError("invalid selection mode")
+    lineage = [[i] for i in range(depth)]
+    records = []
+    model.eval()
+    while len(model.model.layers) > target_layers:
+        step = len(records) + 1
+        print(
+            f"MKA stage {step}: collecting features for {len(lineage)} layers",
+            flush=True,
+        )
+        features = collect_features(model, batches, pooling=geometry.pooling)
+        results = [diffusion_embedding(x, geometry) for x in features]
+        del features
+        scores, entropies = npib_matrix([x[0] for x in results], geometry)
+        left = select_pair(
+            scores,
+            selection=selection,
+            protected_first=protected_first,
+            protected_last=protected_last,
+        )
+        ratio = upstream_lambda(scores, left, left + 1, geometry.beta)
+        record = {
+            "step": step,
+            "selection": selection,
+            "left_index": left,
+            "source_layers": [lineage[left][:], lineage[left + 1][:]],
+            "pair_npib": float(scores[left, left + 1]),
+            "lambda_left": ratio,
+            "lambda_right": 1 - ratio,
+            "row_means": scores.mean(1).tolist(),
+            "npib_matrix": scores.tolist(),
+            "entropies": entropies,
+            "geometry": asdict(geometry),
+            "manifolds": [x[1] for x in results],
+        }
+        record["changed_parameter_tensors"] = merge_pair(model, left, ratio)
+        lineage[left] += lineage.pop(left + 1)
+        record["lineage_after"] = [x[:] for x in lineage]
+        record["remaining_layers"] = len(lineage)
+        records.append(record)
+        print(
+            f"MKA stage {step}: merge {left}/{left + 1}, NPIB={record['pair_npib']:.6g}, "
+            f"lambda={ratio:.6g}, remaining={len(lineage)}",
+            flush=True,
+        )
+        if on_stage is not None:
+            on_stage(model, record)
+    return records

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/fixed_span_merge_init.py

@@ -0,0 +1,59 @@
+"""MLP-only merge rules; fixed topology and feature transport belong to caller.
+
+CoMe importance/neuron scores and MKA manifold scores are measured on the
+previous-cycle teacher, on the same calibration data. This helper consumes the
+actual post-transport operands. No selector, attention merge, norm merge, or
+teacher mutation is allowed here. These are hybrid controls, not native methods.
+"""
+from __future__ import annotations
+
+import copy
+import hashlib
+from types import SimpleNamespace
+
+import torch
+
+MLP_NAMES = ("mlp.gate_proj.weight", "mlp.up_proj.weight", "mlp.down_proj.weight")
+
+
+def tensor_hash(value):
+    raw = value.detach().cpu().contiguous().view(torch.uint8).numpy().tobytes()
+    return hashlib.sha256(raw).hexdigest()
+
+
+def frozen_hashes(layer):
+    return {n: tensor_hash(p) for n, p in layer.named_parameters() if n not in MLP_NAMES}
+
+
+def build_initialization(a, transported_b, method, payload):
+    before_a, before_b = frozen_hashes(a), frozen_hashes(transported_b)
+    a_mlp = {n: tensor_hash(a.get_parameter(n)) for n in MLP_NAMES}
+    b_mlp = {n: tensor_hash(transported_b.get_parameter(n)) for n in MLP_NAMES}
+    if method == "come":
+        from fusegpt.come import merge_mlp
+        # Copy only the two MLPs, not the entire blocks/models. Preserve native
+        # channel concatenation order and BF16 rounding of the CoMe helper.
+        pair = [SimpleNamespace(mlp=copy.deepcopy(layer.mlp).cpu()) for layer in (a, transported_b)]
+        counts = merge_mlp(pair, payload["ratios"], payload["neuron_scores"])
+        result = {"mlp." + n: p.detach().float().clone() for n, p in pair[0].mlp.named_parameters()}
+        detail = {"retention_ratios": payload["ratios"], "retained_mlp_neurons": counts}
+        del pair
+    elif method == "mka":
+        ratio = float(payload["lambda_left"])
+        if not 0 <= ratio <= 1:
+            raise ValueError("Invalid MKA merge coefficient")
+        result = {n: torch.lerp(transported_b.get_parameter(n).detach().float(),
+                              a.get_parameter(n).detach().float(), ratio) for n in MLP_NAMES}
+        detail = {"lambda_left": ratio, "lambda_right": 1 - ratio}
+    else:
+        raise ValueError(method)
+    assert set(result) == set(MLP_NAMES)
+    assert frozen_hashes(a) == before_a and frozen_hashes(transported_b) == before_b
+    assert {n: tensor_hash(a.get_parameter(n)) for n in MLP_NAMES} == a_mlp
+    assert {n: tensor_hash(transported_b.get_parameter(n)) for n in MLP_NAMES} == b_mlp
+    assert all(torch.isfinite(v).all() for v in result.values())
+    return result, {**detail, "source_weights": "post_feature_transport",
+        "scoring_context": "previous_cycle_teacher_before_transport",
+        "anchor_mlp_sha256": a_mlp, "transported_source_mlp_sha256": b_mlp,
+        "initial_mlp_sha256": {n: tensor_hash(v) for n, v in result.items()},
+        "frozen_anchor_sha256": before_a, "operands_unchanged_by_initializer": True}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/launch_qwen3_nofit_bench8.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+set -euo pipefail
+project="$1"; root="$2"; model="$3"; alias="$4"
+export HF_HOME=/workspace/.hf_home HF_TOKEN_PATH=/root/.cache/huggingface/token
+export HF_DATASETS_CACHE=/workspace/.hf_datasets36 HF_DATASETS_TRUST_REMOTE_CODE=1
+export PYTHONUNBUFFERED=1 TOKENIZERS_PARALLELISM=false OMP_NUM_THREADS=4 PYTHONPATH="$project/src"
+mkdir -p "$root"
+trap 'rc=$?; if ((rc)); then touch "$root/FAILED"; fi' EXIT
+while [[ ! -f "$root/EVAL_READY" ]]; do [[ ! -f "$root/BOOTSTRAP_FAILED" ]] || exit 1; sleep 3; done
+export HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 TRANSFORMERS_OFFLINE=1
+run_arm() (
+ arm="$1"; export CUDA_VISIBLE_DEVICES="$2"; out="$root/full/$arm"; stage="$out/compact/stage_09"
+ trap 'rc=$?; if ((rc)); then touch "$root/${arm}_FAILED"; fi' EXIT
+ mkdir -p "$out/logs"
+ if [[ ! -f "$out/eval/final_opencompass5.json" ]]; then
+  python "$project/scripts/eval_opencompass_ppl_fast.py" --model "$model" --tokenizer "$model" \
+   --revision 49e3418fbbbca6ecbdf9608b4d22e5a407081db4 --compact-stage "$stage" --cycle 9 --anchor 12 \
+   --data-root "$root/eval_data/data" --max-batch 32 --token-budget 8192 \
+   --output "$out/eval/final_opencompass5.json" > "$out/logs/opencompass.log" 2>&1
+ fi
+ if [[ ! -f "$out/eval/new_lmeval3.json" ]]; then
+  python "$project/scripts/eval_llama31_8b_12bench.py" --model "$model" \
+   --revision 49e3418fbbbca6ecbdf9608b4d22e5a407081db4 --compact-stage "$stage" --cycle 9 --anchor 12 \
+   --batch-size auto:4 --tasks sciq mmlu cmmlu --dataset-cache "$root/lmeval_cache" --local-files-only \
+   --output "$out/eval/new_lmeval3.json" > "$out/logs/lmeval3.log" 2>&1
+ fi
+ python "$project/scripts/merge_nofit_existing_zs6.py" "$out/eval/zs6.json" "$out/eval/new_lmeval3.json" "$out/eval/final_lmeval9.json"
+ python "$project/scripts/aggregate_transport_rho_fit_14bench.py" "$out" > "$out/logs/aggregate.log"
+ touch "$out/EVAL_COMPLETE"
+)
+run_arm off 0 > "$root/off_pipeline.log" 2>&1 & off_pid=$!
+run_arm on 1 > "$root/on_pipeline.log" 2>&1 & on_pid=$!
+failed=0;for pid in "$off_pid" "$on_pid";do wait "$pid" || failed=1;done
+((failed==0)) || exit 1
+python - "$root" "$project" <<'PY'
+import json,shutil,subprocess,sys
+from pathlib import Path
+r,project=map(Path,sys.argv[1:]); backup=r/'backup';backup.mkdir(exist_ok=True)
+old=json.loads((project/'results/qwen3_8b_base_nofit_transport_zs6_20261009/summary_with_ppl.json').read_text())
+rows=[]
+for row in old['rows']:
+ arm=row['transport'];out=r/'full'/arm
+ report=json.loads((out/'eval/final_14bench.json').read_text());scores=report['task_scores']
+ assert len(scores)==14
+ assert all(scores[k]==v for k,v in row['task_scores'].items())
+ row.update(task_scores=scores,zs12_avg=sum(v for k,v in scores.items() if k not in {'mmlu','cmmlu'})/12,
+            mmlu=scores['mmlu'],cmmlu=scores['cmmlu'],bench14_avg=report['macro_mean_14'],
+            zs6_preserved=True,new_task_count=8,weight_restore=json.loads((out/'restore_receipt.json').read_text()))
+ rows.append(row)
+ target=backup/arm;target.mkdir(exist_ok=True)
+ shutil.copytree(out/'eval',target/'eval',dirs_exist_ok=True)
+ shutil.copytree(out/'logs',target/'logs',dirs_exist_ok=True)
+ shutil.copy2(out/'restore_receipt.json',target/'restore_receipt.json')
+summary={'rows':rows,'source_commit':subprocess.check_output(['git','-C',str(project),'rev-parse','HEAD'],text=True).strip(),
+         'protocol':'Unchanged legacy OpenCompass5 + lm-eval9, BF16 eager, zero-shot; immutable existing ZS6 retained; only missing eight newly evaluated'}
+(r/'summary.json').write_text(json.dumps(summary,indent=2)+'\n');shutil.copy2(r/'summary.json',backup/'summary.json')
+code=backup/'code';code.mkdir(exist_ok=True)
+for name in ['bootstrap_qwen3_nofit_bench8.sh','launch_qwen3_nofit_bench8.sh','merge_nofit_existing_zs6.py',
+             'eval_llama31_8b_12bench.py','eval_opencompass_ppl_fast.py','aggregate_transport_rho_fit_14bench.py']:
+ shutil.copy2(project/'scripts'/name,code/name)
+shutil.copy2(project/'exp_md/2026-10-09_qwen3-base-nofit-bench14-supplement.md',backup/'protocol.md')
+PY
+python "$project/scripts/write_tree_manifest.py" "$root/backup"
+HF_HUB_OFFLINE=0 HF_DATASETS_OFFLINE=0 TRANSFORMERS_OFFLINE=0 \
+ python "$project/scripts/upload_verified_hf_tree.py" "$root/backup" --repo-id LJYAI/paper_revision \
+ --path-in-repo "runs/$alias/20261009-qwen3-base-nofit-bench14-supplement" --verify-all-files \
+ --commit-message 'Qwen3 Base Fisher Transport OFF ON no-FiT remaining eight tasks, existing ZS6 preserved' > "$root/backup.json"
+touch "$root/COMPLETE"
+echo 'COMPLETE: results backed up; instance retained by explicit user request.'

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/launch_qwen3_nofit_merge4.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+set -euo pipefail
+project="$1"; external="$2"; root="$3"; model="$4"; alias="$5"
+export HF_HOME=/workspace/.hf_home HF_TOKEN_PATH=/root/.cache/huggingface/token
+export HF_DATASETS_CACHE=/workspace/.hf_datasets36 PYTHONUNBUFFERED=1 TOKENIZERS_PARALLELISM=false OMP_NUM_THREADS=4
+export PYTHONPATH="$external/src:$project/src:$project"
+export HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 TRANSFORMERS_OFFLINE=1
+revision=49e3418fbbbca6ecbdf9608b4d22e5a407081db4
+trap 'rc=$?; if ((rc)); then touch "$root/FAILED"; fi' EXIT
+while [[ ! -f "$root/INPUTS_READY" ]]; do [[ ! -f "$root/BOOTSTRAP_FAILED" ]] || exit 1; sleep 3; done
+run_prune() {
+ local arm="$1" gpu="$2" out="$3" cycles="$4"
+ mkdir -p "$out/logs" "$out/audit" "$out/eval"
+ CUDA_VISIBLE_DEVICES="$gpu" python "$project/scripts/run_qwen3_nofit_merge_control.py" \
+  --external-root "$external" --inputs "$root/inputs" --audit-root "$out/audit" --initializer "$arm" \
+  --model "$model" --output_dir "$out/run" --layer 12 --num_progressive "$cycles" \
+  --dataset slimpajama --dataset_config none --num_samples 64 --seed 42 --seq_len 1024 --batch_size 2 \
+  --skip_distill --norm_policy copy_n1_n2 --fisher_mode param --eps 0 \
+  --no_head_permute_merge --no_head_permute_select --source_feature_transport \
+  --source_feature_transport_ridge_relative 1e-3 --dtype bfloat16 --eval_dtype bfloat16 \
+  --lora_epochs 0 --skip_eval --skip_final_model_save > "$out/logs/prune.log" 2>&1
+ python -m fusegpt.abprune_compact --run-root "$out/run" --output-root "$out/compact" \
+  --model Qwen/Qwen3-8B-Base --base-revision "$revision" --run-id "qwen3_base_nofit_merge_${arm}_20261011" \
+  --cycles "$cycles" --hard-link --layer-order "$(python -c "print(' '.join(['12']*$cycles))")"
+ python "$project/scripts/verify_qwen3_nofit_merge.py" "$out" "$arm" "$cycles"
+ touch "$out/PRUNE_COMPLETE"
+}
+job() (
+ arm="$1"; gpu="$2"; out="$root/full/$arm"; smoke="$root/smoke/$arm"
+ trap 'rc=$?; if ((rc)); then touch "$root/${arm}_FAILED"; fi' EXIT
+ [[ -f "$smoke/PRUNE_COMPLETE" ]] || run_prune "$arm" "$gpu" "$smoke" 2
+ for other in wa wb average mka; do
+  while [[ ! -f "$root/smoke/$other/PRUNE_COMPLETE" ]]; do
+   [[ ! -f "$root/${other}_FAILED" ]] || exit 1; sleep 3
+  done
+ done
+ [[ -f "$out/PRUNE_COMPLETE" ]] || run_prune "$arm" "$gpu" "$out" 9
+ cp "$root/full/base/offline_eval.json" "$out/offline_eval.json"
+ [[ -f "$out/eval/local_mse.json" ]] || CUDA_VISIBLE_DEVICES="$gpu" python "$project/scripts/qwen3_nofit_local_mse.py" \
+  --model "$model" --cache "$root/local_mse_reference" --compact-stage "$out/compact/stage_09" \
+  --output "$out/eval/local_mse.json" > "$out/logs/local_mse.log" 2>&1
+ [[ -f "$out/eval/final_ppl.json" ]] || CUDA_VISIBLE_DEVICES="$gpu" python "$project/scripts/evaluate_abprune_compact_ppl.py" \
+  --model "$model" --revision "$revision" --compact-stage "$out/compact/stage_09" --anchor 12 --cycles 9 \
+  --original-layers 36 --seq-len 2048 --batch-size 1 --output "$out/eval/final_ppl.json" > "$out/logs/ppl.log" 2>&1
+ MODEL_REVISION="$revision" LMEVAL_LOCAL_CACHE="$root/lmeval_cache" \
+  bash "$project/scripts/eval_llama31_fit_ablation_one.sh" "$project" "$out" "$model" "$root/eval_data/data" "$(command -v python)" 12 9 "$gpu"
+ touch "$out/EVAL_COMPLETE"
+ backup="$root/backup/$arm"
+ python "$project/scripts/package_qwen3_nofit_merge_backup.py" "$out" "$backup" "$project" "$external" "$root"
+ python "$project/scripts/write_tree_manifest.py" "$backup"
+ HF_HUB_OFFLINE=0 HF_DATASETS_OFFLINE=0 TRANSFORMERS_OFFLINE=0 python "$project/scripts/upload_verified_hf_tree.py" \
+  "$backup" --repo-id LJYAI/paper_revision --path-in-repo "runs/$alias/20261011-qwen3-base-nofit-merge4/$arm" \
+  --verify-all-files --commit-message "Qwen3 base no-FiT merge control $arm; all9 stages" > "$root/${arm}_backup.json"
+ touch "$out/BACKUP_COMPLETE"
+)
+pids=(); gpu=0
+for arm in wa wb average mka; do job "$arm" "$gpu" > "$root/${arm}_pipeline.log" 2>&1 & pids+=("$!"); gpu=$((gpu+1)); done
+failed=0; for pid in "${pids[@]}"; do wait "$pid" || failed=1; done
+((failed==0)) || exit 1
+python "$project/scripts/summarize_qwen3_nofit_merge.py" "$root" "$project"
+git -C "$project" add results/qwen3_base_nofit_merge4_20261011
+git -C "$project" commit -m 'Record four Qwen3 no-FiT transported merge controls and verified all-stage backups'
+touch "$root/COMPLETE" "$root/RECORDS_COMMITTED"
+echo 'Complete; retain instance until explicitly authorized to return.'

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/launch_qwen3_nofit_transport_zs6.sh

@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+set -euo pipefail
+project="$1"; external="$2"; root="$3"; model="$4"; alias="$5"
+source "$project/scripts/qwen3_nofit_transport_config.sh"
+export HF_HOME=/workspace/.hf_home HF_TOKEN_PATH=/root/.cache/huggingface/token
+export HF_DATASETS_CACHE=/workspace/.hf_datasets36 PYTHONUNBUFFERED=1
+export PYTHONPATH="$project/src:$external/src:$project"
+trap 'rc=$?; if ((rc)); then touch "$root/FAILED"; fi' EXIT
+prepare_eval() (
+ trap 'rc=$?; if ((rc)); then touch "$root/EVAL_FAILED"; fi' EXIT
+ while [[ ! -f "$root/DEPS_READY" || ! -f "$root/EVAL_ASSETS_READY" ]]; do [[ ! -f "$root/BOOTSTRAP_FAILED" ]] || exit 1; sleep 3; done
+ tar -xzf "$root/lmeval-cache-131.tar.gz" -C "$root"
+ HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 python "$project/scripts/prepare_lmeval9_local_cache.py" "$root/lmeval_cache" --validate-local
+ touch "$root/EVAL_READY"
+)
+prepare_eval > "$root/eval_prepare.log" 2>&1 & eval_pid=$!
+verify() {
+ python - "$1" "$2" "$3" <<'PY'
+import json,sys,os
+from pathlib import Path
+r=Path(sys.argv[1]); arm=sys.argv[2]; cycles=int(sys.argv[3])
+anchor=int(os.environ['NOFIT_ANCHOR'])
+for c in range(1,cycles+1):
+ m=json.loads((r/f'run/cycle_{c}/cycle_metadata.json').read_text())
+ f=json.loads((r/f'audit/cycle_{c:02d}_fit.json').read_text())
+ assert m['layer_merged']==anchor and m['num_layers_after']==36-c
+ assert m['fisher_num_batches']==32
+ assert m['distill']['reparam_skip_train'] and not m['distill']['reparam_stats']['trained']
+ assert f['attention_norm_unchanged'] and f['stats']['epochs']==0
+ assert bool(m['source_feature_transport'])==(arm=='on')
+ assert not m['lora']['enabled'] and not (m['comm'] or {}).get('enabled',False)
+meta=json.loads((r/f'compact/stage_{cycles:02d}/metadata.json').read_text())
+assert meta['removed_original_layers']==list(range(anchor+1,anchor+1+cycles))
+assert meta['model']==os.environ['NOFIT_MODEL_ID'] and meta['base_model_revision']==os.environ['NOFIT_MODEL_REVISION']
+if meta['format']=='abprune_compact_stage_v2':
+ assert meta['active_original_layers']==list(range(anchor+1))+list(range(anchor+1+cycles,36))
+else:
+ assert meta['anchor_index']==anchor and meta['removed_count']==cycles
+print('MATCHED_FISHER_NO_FIT_VERIFIED',arm,cycles,flush=True)
+PY
+}
+job() (
+ arm="$1"; gpu="$2"
+ trap 'rc=$?; if ((rc)); then touch "$root/${arm}_FAILED"; fi' EXIT
+ while [[ ! -f "$root/BASE_READY" ]]; do [[ ! -f "$root/BOOTSTRAP_FAILED" ]] || exit 1; sleep 3; done
+ smoke="$root/smoke/$arm"; out="$root/full/$arm"
+ if [[ ! -f "$smoke/VERIFIED" ]]; then
+  if [[ ! -f "$smoke/PRUNE_COMPLETE" ]]; then
+   bash "$project/scripts/run_qwen3_nofit_transport_arm.sh" "$project" "$external" "$smoke" "$model" "$arm" "$gpu" 2
+  fi
+  verify "$smoke" "$arm" 2; touch "$smoke/VERIFIED"
+ fi
+ while [[ ! -f "$root/smoke/off/VERIFIED" || ! -f "$root/smoke/on/VERIFIED" ]]; do
+  [[ ! -f "$root/off_FAILED" && ! -f "$root/on_FAILED" ]] || exit 1; sleep 2
+ done
+ python - "$root" <<'PY'
+import json,sys
+from pathlib import Path
+r=Path(sys.argv[1])
+assert json.loads((r/'smoke/off/audit/data_fingerprints.json').read_text())==json.loads((r/'smoke/on/audit/data_fingerprints.json').read_text())
+print('PAIRED_SMOKE_DATA_IDENTICAL',flush=True)
+PY
+ if [[ ! -f "$out/PRUNE_COMPLETE" ]]; then
+  bash "$project/scripts/run_qwen3_nofit_transport_arm.sh" "$project" "$external" "$out" "$model" "$arm" "$gpu" 9
+ fi
+ verify "$out" "$arm" 9
+ while [[ ! -f "$root/EVAL_READY" ]]; do [[ ! -f "$root/EVAL_FAILED" ]] || exit 1; sleep 3; done
+ if [[ ! -f "$out/eval/zs6.json" ]]; then
+  CUDA_VISIBLE_DEVICES="$gpu" HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 TRANSFORMERS_OFFLINE=1 \
+  python "$project/scripts/eval_abprune_compact_zeroshot.py" --model "$model" \
+   --revision "$NOFIT_MODEL_REVISION" --compact-stage "$out/compact/stage_09" \
+   --cycle 9 --anchor "$NOFIT_ANCHOR" --batch-size 8 --dataset-cache "$root/lmeval_cache" --output "$out/eval/zs6.json" > "$out/logs/zs6.log" 2>&1
+ fi
+ if [[ "$NOFIT_MEASURE_PPL" == 1 && ! -f "$out/eval/final_ppl.json" ]]; then
+  CUDA_VISIBLE_DEVICES="$gpu" HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 TRANSFORMERS_OFFLINE=1 \
+  python "$project/scripts/evaluate_abprune_compact_ppl.py" --model "$model" --revision "$NOFIT_MODEL_REVISION" \
+   --compact-stage "$out/compact/stage_09" --anchor "$NOFIT_ANCHOR" --cycles 9 --original-layers 36 \
+   --seq-len 2048 --batch-size 4 --output "$out/eval/final_ppl.json" > "$out/logs/ppl.log" 2>&1
+ fi
+ touch "$out/EVAL_COMPLETE"
+ backup="$root/backup/$arm"
+ if [[ ! -d "$backup" ]]; then
+  python "$project/scripts/package_final_fit_backup.py" "$out" "$backup" "$project" "$external" \
+   --protocol "$NOFIT_PROTOCOL" --cycles 9 --original-layers 36
+  cp "$project/scripts/run_qwen3_nofit_transport_control.py" "$project/scripts/run_qwen3_nofit_transport_arm.sh" \
+   "$project/scripts/launch_qwen3_nofit_transport_zs6.sh" "$project/scripts/qwen3_nofit_transport_config.sh" \
+   "$project/scripts/eval_abprune_compact_zeroshot.py" "$backup/code/"
+  git -C "$project" rev-parse HEAD > "$backup/code/project_commit.txt"
+  python "$project/scripts/write_tree_manifest.py" "$backup"
+ fi
+ HF_HUB_OFFLINE=0 HF_DATASETS_OFFLINE=0 TRANSFORMERS_OFFLINE=0 \
+ python "$project/scripts/upload_verified_hf_tree.py" "$backup" --repo-id LJYAI/paper_revision \
+  --path-in-repo "runs/$alias/$NOFIT_RUN_SLUG/$arm" --verify-all-files \
+  --commit-message "Qwen3 ${QWEN_NOFIT_VARIANT:-base} matched Fisher transport $arm no FiT" > "$root/${arm}_backup.json"
+ touch "$out/BACKUP_COMPLETE"
+)
+job off 0 > "$root/off_pipeline.log" 2>&1 & off_pid=$!
+job on 1 > "$root/on_pipeline.log" 2>&1 & on_pid=$!
+failed=0; for pid in "$off_pid" "$on_pid" "$eval_pid"; do wait "$pid" || failed=1; done
+((failed==0)) || exit 1
+python - "$root" <<'PY'
+import json,sys,os
+from pathlib import Path
+r=Path(sys.argv[1]); rows=[]; fingerprints=[]
+anchor=int(os.environ['NOFIT_ANCHOR'])
+for arm in ['off','on']:
+ out=r/'full'/arm; result=json.loads((out/'eval/zs6.json').read_text())
+ fp=json.loads((out/'audit/data_fingerprints.json').read_text()); fingerprints.append(fp)
+ rows.append(dict(model=os.environ['NOFIT_MODEL_ID'],model_revision=os.environ['NOFIT_MODEL_REVISION'],removed_blocks=9,anchor=anchor,removed_original_layers=list(range(anchor+1,anchor+10)),
+                  transport=arm,fit=False,fisher='same_anchor_contextual',task_scores=result['task_scores'],
+                  zs6=result['six_task_mean'],backup=json.loads((r/f'{arm}_backup.json').read_text())))
+ if os.environ['NOFIT_MEASURE_PPL']=='1':
+  ppl=json.loads((out/'eval/final_ppl.json').read_text())
+  assert ppl['metrics']['sequences']==145 and ppl['metrics']['tokens']==296815
+  rows[-1]['ppl']=ppl['metrics']['perplexity']
+assert fingerprints[0]==fingerprints[1]
+(r/'summary.json').write_text(json.dumps(rows,indent=2)+'\n')
+PY
+touch "$root/COMPLETE"

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/monitor_qwen3_nofit_bench8.ps1

@@ -0,0 +1,58 @@
+param(
+ [string]$HostAlias='vast-paper_revision-qwen3-base-nofit-bench8-54984557-20261009',
+ [string]$LogDirectory='C:\Users\CELL\orca\artifacts\paper_revision\qwen3-base-nofit-bench8-20261009-monitor',
+ [ValidatePattern('^/workspace/artifacts/[A-Za-z0-9._-]+$')]
+ [string]$RemoteRoot='/workspace/artifacts/qwen3-base-nofit-bench8-20261009',
+ [ValidateRange(30,3600)][int]$IntervalSeconds=180
+)
+$ErrorActionPreference='Stop'
+New-Item -ItemType Directory -Force -Path $LogDirectory | Out-Null
+$poll=@'
+from pathlib import Path
+import json,re,time,subprocess
+r=Path('__ROOT__')
+def tail(p):
+ return [re.sub(r'https?://\S+','[URL omitted]',s)[-500:] for s in p.read_text(errors='replace').splitlines()[-2:]] if p.exists() else []
+arms={}
+for arm in ['off','on']:
+ d=r/'full'/arm
+ arms[arm]={'markers':[m for m in ['EVAL_COMPLETE','BENCH14_COMPLETE'] if (d/m).exists()],
+ 'logs':{n:tail(d/'logs'/n) for n in ['opencompass.log','lmeval3.log']},
+ 'results':[p.name for p in (d/'eval').glob('*.json')]}
+print('SNAPSHOT_JSON='+json.dumps({'utc':time.strftime('%Y-%m-%dT%H:%M:%SZ',time.gmtime()),
+ 'failed':any((r/m).exists() for m in ['FAILED','BOOTSTRAP_FAILED','off_FAILED','on_FAILED']),
+ 'complete':(r/'COMPLETE').exists(),'markers':[m for m in ['BASE_READY','EVAL_ASSETS_READY','EVAL_READY','BOOTSTRAP_COMPLETE'] if (r/m).exists()],
+ 'arms':arms,'logs':{n:tail(r/n) for n in ['bootstrap.log','controller.log','off_pipeline.log','on_pipeline.log']}}))
+print(subprocess.check_output(['nvidia-smi','--query-gpu=index,utilization.gpu,memory.used','--format=csv,noheader'],text=True))
+'@
+$poll=$poll.Replace('__ROOT__',$RemoteRoot)
+$payload=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($poll.Replace("`r`n","`n")))
+while($true){
+ $lines=@(& ssh -o BatchMode=yes -o ConnectTimeout=15 -o ServerAliveInterval=15 -o ServerAliveCountMax=2 $HostAlias "printf %s $payload | base64 -d | python")
+ $code=$LASTEXITCODE
+ Add-Content -LiteralPath (Join-Path $LogDirectory 'poll.log') -Value (@((Get-Date -Format o))+$lines) -Encoding UTF8
+ $line=$lines | Where-Object {$_ -like 'SNAPSHOT_JSON=*'} | Select-Object -Last 1
+ if($code -eq 0 -and $line){
+  $snapshot=$line.Substring('SNAPSHOT_JSON='.Length) | ConvertFrom-Json
+  if($snapshot.failed){throw 'Benchmark supplement failed; instance retained.'}
+  if($snapshot.complete){
+   $dest=Join-Path $LogDirectory 'completed_results';New-Item -ItemType Directory -Force -Path $dest | Out-Null
+   foreach($name in @('summary.json','backup.json','execution.json')){
+    & scp -O "${HostAlias}:${RemoteRoot}/$name" (Join-Path $dest $name)
+    if($LASTEXITCODE -ne 0){throw "Recovery failed: $name"}
+   }
+   foreach($arm in @('off','on')){
+    $folder=Join-Path $dest $arm;New-Item -ItemType Directory -Force -Path $folder | Out-Null
+    & scp -O "${HostAlias}:${RemoteRoot}/full/$arm/eval/*.json" $folder
+    if($LASTEXITCODE -ne 0){throw "Score recovery failed: $arm"}
+    & scp -O "${HostAlias}:${RemoteRoot}/full/$arm/restore_receipt.json" $folder
+    if($LASTEXITCODE -ne 0){throw "Restore receipt recovery failed: $arm"}
+   }
+   $receipt=Get-Content (Join-Path $dest 'backup.json') -Raw | ConvertFrom-Json
+   if(-not $receipt.verified -or -not $receipt.all_payload_hashes_match){throw 'Backup verification missing'}
+   Add-Content (Join-Path $LogDirectory 'poll.log') 'COMPLETE: scores recovered; instance retained by user request.'
+   break
+  }
+ }
+ Start-Sleep -Seconds $IntervalSeconds
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/monitor_qwen3_nofit_merge4.ps1

@@ -0,0 +1,52 @@
+param(
+ [string]$HostAlias='vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011',
+ [string]$RemoteRoot='/workspace/artifacts/qwen3-base-nofit-merge4-20261011',
+ [string]$LogDirectory='C:\Users\CELL\orca\artifacts\paper_revision\qwen3-base-nofit-merge4-55359231-20261011-monitor',
+ [int]$IntervalSeconds=300
+)
+$ErrorActionPreference='Stop'
+New-Item -ItemType Directory -Force -Path $LogDirectory | Out-Null
+if ($RemoteRoot -notmatch '^/workspace/artifacts/[a-zA-Z0-9._-]+$') { throw 'Unsafe root' }
+$taskPoll=@'
+from pathlib import Path
+import json,subprocess,re,datetime
+r=Path('__ROOT__')
+def tail(p):
+ return [re.sub(r'https?://\S+','[URL]',s)[-500:] for s in p.read_text(errors='replace').splitlines()[-3:]] if p.exists() else []
+arms={}
+for arm in ('wa','wb','average','mka'):
+ a=r/'full'/arm
+ arms[arm]=dict(cycles=len(list((a/'run').glob('cycle_*/cycle_metadata.json'))),
+  smoke_cycles=len(list((r/'smoke'/arm/'run').glob('cycle_*/cycle_metadata.json'))),
+  markers=[x for x in ('PRUNE_COMPLETE','EVAL_COMPLETE','BACKUP_COMPLETE') if (a/x).exists()],
+  logs={str(p):tail(a/p) for p in map(Path,['logs/prune.log','logs/local_mse.log','logs/ppl.log','logs/eval14.log'])})
+state=dict(utc=datetime.datetime.now(datetime.timezone.utc).isoformat(),
+ failed=[p.name for p in r.glob('*FAILED')], complete=(r/'RECORDS_COMMITTED').exists(),
+ markers=[x for x in ('DEPS_READY','BASE_READY','DATA_READY','EVAL_READY','COMMON_TEACHER_READY','INPUTS_READY','COMPLETE') if (r/x).exists()],
+ logs={str(p):tail(r/p) for p in map(Path,['bootstrap.log','controller.log','data_prepare.log','local_mse_prepare.log'])},arms=arms)
+print('SNAPSHOT_JSON='+json.dumps(state))
+print(subprocess.check_output(['nvidia-smi','--query-gpu=index,utilization.gpu,memory.used','--format=csv,noheader'],text=True))
+'@
+$taskPoll=$taskPoll.Replace('__ROOT__',$RemoteRoot)
+$taskEncoded=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($taskPoll.Replace("`r`n","`n")))
+while ($true) {
+ $taskPreference=$ErrorActionPreference
+ $ErrorActionPreference='Continue'
+ $taskLines=@(& ssh -o BatchMode=yes -o ConnectTimeout=15 -o ServerAliveInterval=15 -o ServerAliveCountMax=2 $HostAlias "printf %s $taskEncoded | base64 -d | python" 2>$null)
+ $ErrorActionPreference=$taskPreference
+ $taskLine=$taskLines | Where-Object { $_ -like 'SNAPSHOT_JSON=*' } | Select-Object -Last 1
+ Add-Content -LiteralPath (Join-Path $LogDirectory 'poll.log') -Value (@((Get-Date -Format o))+$taskLines) -Encoding UTF8
+ if ($taskLine) {
+  $taskState=$taskLine.Substring(14) | ConvertFrom-Json
+  if ($taskState.failed.Count -gt 0) { throw 'Experiment failed; retained. Inspect poll.log.' }
+  if ($taskState.complete) {
+   & powershell.exe -NoProfile -ExecutionPolicy Bypass -File (Join-Path $PSScriptRoot '../receive-project.ps1') -HostAlias $HostAlias
+   if ($LASTEXITCODE -ne 0) { throw 'Commit recovery failed' }
+   & git -C (Join-Path $PSScriptRoot '..') push origin "codex/$HostAlias"
+   if ($LASTEXITCODE -ne 0) { throw 'Local push failed' }
+   Add-Content -LiteralPath (Join-Path $LogDirectory 'poll.log') -Value 'COMPLETE: result commit recovered and pushed; instance retained.'
+   break
+  }
+ }
+ Start-Sleep -Seconds $IntervalSeconds
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/monitor_qwen3_nofit_transport_zs6.ps1

@@ -0,0 +1,78 @@
+param(
+ [string]$HostAlias='vast-paper_revision-qwen3-base-nofit-transport-zs6-54974094-20261009',
+ [string]$LogDirectory='C:\Users\CELL\orca\artifacts\paper_revision\qwen3-base-nofit-transport-zs6-20261009-monitor',
+ [string]$RemoteRoot='/workspace/artifacts/qwen3-base-nofit-transport-zs6-20261009',
+ [ValidateRange(30,3600)][int]$IntervalSeconds=300,
+ [ValidateRange(1,40)][int]$RemovedBlocks=9,
+ [switch]$FullBench14
+)
+$ErrorActionPreference='Stop'
+New-Item -ItemType Directory -Force -Path $LogDirectory | Out-Null
+$root=$RemoteRoot
+if ($root -notmatch '^/workspace/artifacts/[A-Za-z0-9._-]+$') { throw 'Unsafe remote artifact root' }
+$poll=@'
+from pathlib import Path
+import json,re,time,subprocess
+r=Path('__REMOTE_ROOT__')
+def tail(p):
+ return [re.sub(r'https?://\S+','[URL omitted]',s)[-500:] for s in p.read_text(errors='replace').splitlines()[-3:]] if p.exists() else []
+arms={}
+for arm in ['off','on']:
+ d=r/'full'/arm;s=r/'smoke'/arm
+ arms[arm]={'smoke_verified':(s/'VERIFIED').exists(),
+ 'markers':[m for m in ['PRUNE_COMPLETE','EVAL_COMPLETE','BACKUP_COMPLETE'] if (d/m).exists()],
+ 'cycles':len(list((d/'run').glob('cycle_*/cycle_metadata.json'))),
+ 'logs':{phase:{n:tail(r/phase/arm/'logs'/n) for n in ['prune.log','zs6.log','ppl.log','eval14.log']} for phase in ['smoke','full']}}
+print('SNAPSHOT_JSON='+json.dumps({'utc':time.strftime('%Y-%m-%dT%H:%M:%SZ',time.gmtime()),
+ 'failed':any((r/m).exists() for m in ['FAILED','BOOTSTRAP_FAILED','EVAL_FAILED','off_FAILED','on_FAILED']),
+ 'complete':(r/'COMPLETE').exists(),'arms':arms,
+ 'logs':{n:tail(r/n) for n in ['bootstrap.log','eval_prepare.log','controller.log','off_pipeline.log','on_pipeline.log']}}))
+print(subprocess.check_output(['nvidia-smi','--query-gpu=index,utilization.gpu,memory.used','--format=csv,noheader'],text=True))
+'@
+$poll=$poll.Replace('__REMOTE_ROOT__',$root)
+$payload=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($poll.Replace("`r`n","`n")))
+while ($true) {
+ $lines=@(& ssh -o BatchMode=yes -o ConnectTimeout=15 -o ServerAliveInterval=15 -o ServerAliveCountMax=2 $HostAlias "printf %s $payload | base64 -d | python")
+ $code=$LASTEXITCODE
+ Add-Content -LiteralPath (Join-Path $LogDirectory 'poll.log') -Value (@((Get-Date -Format o))+$lines) -Encoding UTF8
+ $line=$lines | Where-Object { $_ -like 'SNAPSHOT_JSON=*' } | Select-Object -Last 1
+ if ($code -eq 0 -and $line) {
+  $snapshot=$line.Substring('SNAPSHOT_JSON='.Length) | ConvertFrom-Json
+  if ($snapshot.failed) { throw 'No-FiT transport control failed; inspect logs. Instance retained.' }
+  if ($snapshot.complete) {
+   $dest=Join-Path $LogDirectory 'completed_results'
+   New-Item -ItemType Directory -Force -Path $dest | Out-Null
+   & scp "${HostAlias}:${root}/summary.json" (Join-Path $dest 'summary.json')
+   if ($LASTEXITCODE -ne 0) { throw 'Summary recovery failed' }
+   foreach ($arm in @('off','on')) {
+    $folder=Join-Path $dest $arm
+    New-Item -ItemType Directory -Force -Path $folder | Out-Null
+    if ($FullBench14) {
+     & scp -O "${HostAlias}:${root}/full/${arm}/eval/*.json" $folder
+    } else {
+     & scp "${HostAlias}:${root}/full/${arm}/eval/zs6.json" (Join-Path $folder 'zs6.json')
+    }
+    if ($LASTEXITCODE -ne 0) { throw "Evaluation recovery failed: $arm" }
+    if ($rowHasPpl = ($snapshot.arms.$arm.logs.full.'ppl.log'.Count -gt 0)) {
+     & scp "${HostAlias}:${root}/full/${arm}/eval/final_ppl.json" (Join-Path $folder 'final_ppl.json')
+     if ($LASTEXITCODE -ne 0) { throw "PPL recovery failed: $arm" }
+    }
+    & scp -r "${HostAlias}:${root}/full/${arm}/audit" $folder
+    if ($LASTEXITCODE -ne 0) { throw "Audit recovery failed: $arm" }
+    & scp "${HostAlias}:${root}/${arm}_backup.json" (Join-Path $folder 'backup.json')
+    if ($LASTEXITCODE -ne 0) { throw "Backup receipt recovery failed: $arm" }
+   }
+   $rows=Get-Content -LiteralPath (Join-Path $dest 'summary.json') -Raw -Encoding UTF8 | ConvertFrom-Json
+   if ($FullBench14) { $rows=$rows.rows }
+   if ($rows.Count -ne 2) { throw 'Expected two completed arms' }
+   foreach ($row in $rows) {
+    if ($row.fit -or $row.removed_blocks -ne $RemovedBlocks -or -not $row.backup.verified -or -not $row.backup.all_payload_hashes_match) {
+     throw 'Protocol/backup mismatch'
+    }
+   }
+   Add-Content -LiteralPath (Join-Path $LogDirectory 'poll.log') -Value 'COMPLETE: both controls recovered; instance retained.'
+   break
+  }
+ }
+ Start-Sleep -Seconds $IntervalSeconds
+}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/nofit_merge_control.py

@@ -0,0 +1,37 @@
+"""Exact non-Fisher merge controls; never construct an optimizer or FiT U."""
+from __future__ import annotations
+
+import torch
+from fusegpt.fixed_span_merge_init import MLP_NAMES, tensor_hash
+from fusegpt.fit_ablation_mka import PROJECTION_WEIGHTS
+
+
+def merge_in_place(a, transported_b, method, *, mka_lambda=None):
+    ratio = {"wa": 1., "wb": 0., "average": .5}.get(method, mka_lambda)
+    if method not in {"wa", "wb", "average", "mka"} or ratio is None or not 0 <= ratio <= 1:
+        raise ValueError((method, ratio))
+    names = tuple(PROJECTION_WEIGHTS) if method == "mka" else MLP_NAMES
+    frozen = {n: tensor_hash(p) for n, p in a.named_parameters() if n not in names}
+    source = {n: tensor_hash(p) for n, p in transported_b.named_parameters()}
+    before = {n: tensor_hash(a.get_parameter(n)) for n in names}
+    with torch.no_grad():
+        for name in names:
+            left = a.get_parameter(name)
+            right = transported_b.get_parameter(name)
+            assert left.shape == right.shape
+            # Match the corrected MKA / exact endpoint controls: FP32 mix,
+            # one cast to deployed BF16. No sigmoid endpoint clamping.
+            initial = left.detach().clone() if ratio == 1 else (
+                right.detach().clone() if ratio == 0 else
+                torch.lerp(right.detach().float(), left.detach().float(), ratio).to(left.dtype))
+            assert torch.isfinite(initial).all(), name
+            left.copy_(initial)
+    assert {n: tensor_hash(p) for n, p in a.named_parameters() if n not in names} == frozen
+    assert {n: tensor_hash(p) for n, p in transported_b.named_parameters()} == source
+    return {"initializer": method, "lambda_left": ratio, "lambda_right": 1 - ratio,
+            "projection_names": list(names), "scope": "attention_and_mlp" if method == "mka" else "mlp",
+            "frozen_anchor_sha256": frozen, "anchor_before_sha256": before,
+            "source_post_transport_sha256": source,
+            "anchor_after_sha256": {n: tensor_hash(a.get_parameter(n)) for n in names},
+            "norm_policy": "keep_Wa_including_QK_norms", "source_mutated_by_merge": False,
+            "fisher_computed": False, "fit": False, "optimizer_steps": 0, "backward_calls": 0}

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/offline_eval_policy.py

@@ -0,0 +1,26 @@
+"""Run-local offline policy, applied before importing Hugging Face libraries."""
+import json
+import os
+from pathlib import Path
+
+
+def apply_run_offline_policy(argv):
+    output = None
+    for index, value in enumerate(argv):
+        if value == '--output' and index + 1 < len(argv):
+            output = argv[index + 1]
+        elif value.startswith('--output='):
+            output = value.split('=', 1)[1]
+    if output is None:
+        return None
+    policy_path = Path(output).parent.parent / 'offline_eval.json'
+    if not policy_path.is_file():
+        return None
+    policy = json.loads(policy_path.read_text())
+    cache = Path(policy['wikitext_cache'])
+    if not (cache / 'dataset_dict.json').is_file():
+        raise FileNotFoundError(f'Offline WikiText cache missing: {cache}; no online fallback')
+    for key in ('HF_HUB_OFFLINE', 'HF_DATASETS_OFFLINE', 'TRANSFORMERS_OFFLINE'):
+        os.environ[key] = '1'
+    print('STRICT_OFFLINE_RUN_POLICY_APPLIED', flush=True)
+    return policy

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/package_qwen3_nofit_merge_backup.py

@@ -0,0 +1,47 @@
+"""Retain every stage, not just final weights; enable previous-teacher MSE."""
+from pathlib import Path
+import json
+import shutil
+import sys
+out,backup,project,external,root=map(Path,sys.argv[1:])
+backup.mkdir(parents=True,exist_ok=True)
+def link_immutable(src,dst):
+ src,dst=Path(src),Path(dst)
+ if dst.exists():
+  assert src.samefile(dst), f'Refusing to overwrite non-linked file: {dst}'
+ else:
+  dst.hardlink_to(src)
+ return str(dst)
+for folder in ('compact','audit','eval','logs'):
+ shutil.copytree(out/folder,backup/folder,dirs_exist_ok=True,
+  copy_function=link_immutable if folder in ('compact','audit') else shutil.copy2)
+assert len(list((backup/'compact').glob('stage_*/*.pt')))==9
+for c in range(1,10):
+ d=backup/f'cycle_metadata/cycle_{c}';d.mkdir(parents=True,exist_ok=True)
+ shutil.copy2(out/f'run/cycle_{c}/cycle_metadata.json',d/'cycle_metadata.json')
+shutil.copytree(root/'inputs',backup/'inputs',dirs_exist_ok=True)
+# Dense activations are shared across the four arms. Exact inputs + original
+# immutable teacher revision suffice to regenerate them; save protocol here.
+shutil.copy2(root/'local_mse_reference/protocol.json',backup/'local_mse_protocol.json')
+shutil.copy2(root/'local_mse_reference/evaluation_input_ids.pt',backup/'inputs/local_mse_evaluation_input_ids.pt')
+shutil.copy2(root/'fisher_reference/local_mse.json',backup/'fisher_reference_local_mse.json')
+shutil.copy2(root/'fisher_reference/restore_receipt.json',backup/'fisher_reference_restore_receipt.json')
+code=backup/'code';code.mkdir(exist_ok=True)
+for path in [*project.glob('scripts/*qwen3_nofit*'),project/'src/fusegpt/nofit_merge_control.py',
+ project/'src/fusegpt/fit_ablation_mka.py',project/'src/fusegpt/fixed_span_merge_init.py',
+ project/'src/fusegpt/abprune_compact.py',project/'src/fusegpt/abprune_stagewise_geometry.py',
+ project/'scripts/eval_llama31_fit_ablation_one.sh',project/'scripts/evaluate_abprune_compact_ppl.py',
+ project/'scripts/evaluate_hchc_wikitext2_ppl.py',project/'scripts/eval_opencompass_ppl_fast.py',
+ project/'scripts/eval_llama31_8b_12bench.py',project/'scripts/aggregate_transport_rho_fit_14bench.py',
+ project/'scripts/prepare_lmeval9_local_cache.py',project/'scripts/offline_eval_policy.py',
+ project/'exp_md/2026-10-11_qwen3-base-nofit-merge4.md',
+ *[external/'src'/n for n in ['fuse_layers.py','fuse_layers_distill.py','source_feature_transport.py','common_lm_data.py','dm500_rows.py']]]:
+ if path.is_file(): shutil.copy2(path,code/path.name)
+import subprocess
+(code/'project_commit.txt').write_text(subprocess.check_output(['git','-C',str(project),'rev-parse','HEAD'],text=True))
+receipt=dict(stages=list(range(1,10)),stage0_original_model='Qwen/Qwen3-8B-Base',
+ stage0_revision='49e3418fbbbca6ecbdf9608b4d22e5a407081db4',
+ previous_teacher_reconstruction='stage(k-1) compact anchor + immutable original unremoved layers',
+ original_input_ids_saved=True,all_transport_matrices_saved=True,
+ intermediate_weights_saved=True,fit=False)
+(backup/'stage_retention.json').write_text(json.dumps(receipt,indent=2)+'\n')

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/prepare_lmeval9_local_cache.py

@@ -0,0 +1,108 @@
+"""Materialize the exact harness datasets once, without changing task definitions."""
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import hashlib
+import json
+from pathlib import Path
+import time
+
+import datasets
+from lm_eval.tasks import TaskManager
+
+
+def cache_key(path, name, kwargs):
+    return hashlib.sha256(json.dumps([path, name, kwargs], sort_keys=True).encode()).hexdigest()
+
+
+def specs():
+    manager = TaskManager()
+    names = ["piqa", "winogrande", "hellaswag", "arc_challenge", "arc_easy", "openbookqa", "sciq"]
+    entries = [manager.task_index[n] for n in names]
+    entries += [e for e in manager.task_index.values()
+                if e.yaml_path and e.yaml_path.parent.name == "default"
+                and (e.cfg or {}).get("dataset_path") == "cais/mmlu"]
+    entries += [e for e in manager.task_index.values()
+                if (e.cfg or {}).get("dataset_path") == "haonan-li/cmmlu"]
+    unique = {}
+    for entry in entries:
+        cfg = entry.cfg
+        path, name, kwargs = cfg["dataset_path"], cfg.get("dataset_name"), cfg.get("dataset_kwargs") or {}
+        unique[cache_key(path, name, kwargs)] = {"path": path, "name": name, "kwargs": kwargs}
+    assert len(unique) == 131, len(unique)
+    return unique
+
+
+def materialize(root, key, spec, offline):
+    target = root / key
+    metadata = target / "source.json"
+    if metadata.is_file():
+        return key, json.loads(metadata.read_text())
+    start = time.monotonic()
+    try:
+        data = datasets.load_dataset(spec["path"], spec["name"], **spec["kwargs"])
+    except Exception:
+        if offline:
+            return key, None
+        raise
+    data.save_to_disk(str(target))
+    report = {**spec, "splits": {k: {"rows": len(v), "fingerprint": v._fingerprint}
+                                  for k, v in data.items()}}
+    metadata.write_text(json.dumps(report, indent=2) + "\n")
+    restored = datasets.load_from_disk(str(target))
+    assert {k: len(v) for k, v in restored.items()} == {k: len(v) for k, v in data.items()}
+    assert all(restored[k].features == data[k].features for k in data)
+    assert all(restored[k].data.table.equals(data[k].data.table) for k in data)
+    print("READY", spec["path"], spec["name"], round(time.monotonic() - start, 2), flush=True)
+    return key, report
+
+
+def install_local_loader(root):
+    manifest = json.loads((root / "manifest.json").read_text())
+    assert len(manifest) == 131
+    memo = {}
+
+    def local_load(path, name=None, **kwargs):
+        key = cache_key(path, name, kwargs)
+        if key not in manifest:
+            raise RuntimeError(f"Unprepared dataset request: {path}/{name}; no online fallback")
+        if key not in memo:
+            memo[key] = datasets.load_from_disk(str(root / key))
+            print("LOCAL_DATASET", path, name, flush=True)
+        return memo[key]
+
+    datasets.load_dataset = local_load
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("root", type=Path)
+    parser.add_argument("--offline-export", action="store_true")
+    parser.add_argument("--validate-local", action="store_true",
+                        help="Validate a complete transferred cache without Hub requests")
+    parser.add_argument("--workers", type=int, default=8)
+    args = parser.parse_args()
+    args.root.mkdir(parents=True, exist_ok=True)
+    sources = specs()
+    if args.validate_local:
+        manifest = json.loads((args.root / "manifest.json").read_text())
+        assert set(manifest) == set(sources), "Task configuration mismatch"
+        for key, spec in sources.items():
+            report = manifest[key]
+            assert all(report[k] == v for k, v in spec.items())
+            assert json.loads((args.root / key / "source.json").read_text()) == report
+            data = datasets.load_from_disk(str(args.root / key))
+            assert {k: len(v) for k, v in data.items()} == {
+                k: v["rows"] for k, v in report["splits"].items()}
+        print("VALIDATED_LOCAL", len(manifest), "NO_HUB_REQUESTS", flush=True)
+        raise SystemExit(0)
+    completed = {}
+    with ThreadPoolExecutor(max_workers=1 if args.offline_export else args.workers) as executor:
+        futures = [executor.submit(materialize, args.root, k, v, args.offline_export)
+                   for k, v in sources.items()]
+        for future in as_completed(futures):
+            key, result = future.result()
+            if result is not None:
+                completed[key] = result
+    print("PREPARED", len(completed), "OF", len(sources), flush=True)
+    if len(completed) == len(sources):
+        (args.root / "manifest.json").write_text(json.dumps(completed, indent=2) + "\n")

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/prepare_qwen3_nofit_merge_inputs.py

@@ -0,0 +1,35 @@
+"""Materialize the exact historical calibration once for four workers."""
+import argparse
+import json
+import os
+from pathlib import Path
+import sys
+
+p = argparse.ArgumentParser()
+p.add_argument('--external-root', type=Path, required=True)
+p.add_argument('--model', required=True)
+p.add_argument('--output', type=Path, required=True)
+a = p.parse_args()
+sys.path.insert(0, str(a.external_root / 'src'))
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))
+import torch
+from transformers import AutoTokenizer
+from common_lm_data import SharedLMDataSpec, build_chunks
+from fusegpt.fixed_span_merge_init import tensor_hash
+
+os.environ['ABPRUNE_DATASET_REVISION'] = 'b5f90f419b7489cdba26fdbc8c022fcb5562f968'
+tokenizer = AutoTokenizer.from_pretrained(a.model, local_files_only=True)
+chunks = build_chunks(SharedLMDataSpec(dataset='slimpajama', config=None, split='train',
+    text_field='text', seq_len=1024, num_sequences=64, seed=42), tokenizer)
+ids = torch.stack(chunks).long()
+assert ids.shape == (64, 1024)
+assert tensor_hash(ids) == '85a84b9a68cf0856fd363186d3a273860886b1c17f876cae145fd092454aff55'
+a.output.mkdir(parents=True, exist_ok=True)
+torch.save({'input_ids': ids, 'attention_mask': torch.ones_like(ids)}, a.output / 'calib.pt')
+manifest = dict(model='Qwen/Qwen3-8B-Base', model_revision='49e3418fbbbca6ecbdf9608b4d22e5a407081db4',
+    dataset='DKYoon/SlimPajama-6B', revision=os.environ['ABPRUNE_DATASET_REVISION'], split='train',
+    packing='historical nonstreaming dataset.shuffle(seed42); concatenate encoded text without separators or BOS',
+    samples=64, seq_len=1024, batch_size=2, seed=42, valid_tokens=65536,
+    input_ids_sha256=tensor_hash(ids), attention_mask_sha256=tensor_hash(torch.ones_like(ids)))
+(a.output / 'manifest.json').write_text(json.dumps(manifest, indent=2)+'\n')
+print('EXACT_HISTORICAL_CALIBRATION_VERIFIED', json.dumps(manifest), flush=True)

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/project_commit.txt

@@ -0,0 +1 @@
+228a79f631d8ddf633f8f5e77677af7add92c2bc

runs/vast-paper_revision-qwen3-base-nofit-merge4-55359231-20261011/20261011-qwen3-base-nofit-merge4/wb/code/qwen3_nofit_local_mse.py

@@ -0,0 +1,101 @@
+"""Evaluation-only boundary MSE, all variants against the same dense teacher."""
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+import torch
+from fusegpt.fixed_span_merge_init import tensor_hash
+from evaluate_hchc_wikitext2_ppl import packed_wikitext_tokens, primary
+
+REVISION = '49e3418fbbbca6ecbdf9608b4d22e5a407081db4'
+
+
+class BoundaryReached(Exception):
+    pass
+
+
+@torch.no_grad()
+def capture(model, ids, boundary, batch_size=2):
+    outputs, inputs = [], []
+    current = {}
+    def pre(module, args, kwargs):
+        value = args[0] if args else kwargs['hidden_states']
+        current['input'] = value.detach().cpu()
+    def post(module, args, output):
+        current['output'] = primary(output).detach().cpu()
+        raise BoundaryReached()
+    h1 = model.model.layers[12].register_forward_pre_hook(pre, with_kwargs=True)
+    h2 = model.model.layers[boundary].register_forward_hook(post)
+    try:
+        for start in range(0, len(ids), batch_size):
+            current.clear()
+            batch = ids[start:start+batch_size].to('cuda')
+            try:
+                model.model(input_ids=batch, attention_mask=torch.ones_like(batch), use_cache=False)
+            except BoundaryReached:
+                pass
+            else:
+                raise RuntimeError('Boundary hook did not run')
+            inputs.append(current['input'])
+            outputs.append(current['output'])
+    finally:
+        h1.remove(); h2.remove()
+    return torch.cat(inputs), torch.cat(outputs)
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--model', required=True)
+    p.add_argument('--cache', type=Path, required=True)
+    p.add_argument('--wikitext-cache', type=Path)
+    p.add_argument('--prepare', action='store_true')
+    p.add_argument('--compact-stage', type=Path)
+    p.add_argument('--output', type=Path)
+    a = p.parse_args()
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    if a.prepare:
+        assert a.wikitext_cache and not a.compact_stage
+        tokenizer = AutoTokenizer.from_pretrained(a.model, local_files_only=True)
+        ids = packed_wikitext_tokens(tokenizer, 'test', dataset_cache=a.wikitext_cache)[:64*1024].reshape(64,1024)
+        model = AutoModelForCausalLM.from_pretrained(a.model, dtype=torch.bfloat16,
+            local_files_only=True, attn_implementation='eager').to('cuda').eval()
+        anchor_inputs, targets = capture(model, ids, 21)
+        a.cache.mkdir(parents=True, exist_ok=True)
+        torch.save(dict(input_ids=ids, anchor_inputs=anchor_inputs, targets=targets), a.cache/'dense_teacher.pt')
+        torch.save(dict(input_ids=ids, attention_mask=torch.ones_like(ids)), a.cache/'evaluation_input_ids.pt')
+        protocol = dict(model='Qwen/Qwen3-8B-Base', revision=REVISION,
+            teacher='common_original_dense', dense_input_layer=12, dense_output_layer=21,
+            student_output_layer=12, sequences=64, sequence_length=1024, valid_tokens=65536,
+            metric='sum float32 squared activation differences / valid tokens / hidden width',
+            dtype='bfloat16 eager; float32 differences; float64 aggregate', training=False,
+            input_ids_sha256=tensor_hash(ids), anchor_inputs_sha256=tensor_hash(anchor_inputs),
+            targets_sha256=tensor_hash(targets), dataset='WikiText2 test, first64 packed1024 windows, HCHC packing')
+        (a.cache/'protocol.json').write_text(json.dumps(protocol,indent=2)+'\n')
+        print('COMMON_DENSE_TEACHER_READY',json.dumps(protocol),flush=True)
+        return
+    assert a.compact_stage and a.output
+    from fusegpt.abprune_stagewise_geometry import load_compact_model
+    reference = torch.load(a.cache/'dense_teacher.pt',weights_only=True)
+    protocol = json.loads((a.cache/'protocol.json').read_text())
+    for field in ('input_ids','anchor_inputs','targets'):
+        assert tensor_hash(reference[field]) == protocol[field+'_sha256']
+    model = load_compact_model(a.model,a.compact_stage,cycle=9,anchor=12,
+        dtype=torch.bfloat16,device=torch.device('cuda'),attn='eager',revision=REVISION).eval()
+    inputs, outputs = capture(model,reference['input_ids'],12)
+    assert torch.equal(inputs,reference['anchor_inputs']), 'Upstream prefix changed; common MSE inputs not matched'
+    # Keep accumulation chunked; the cached tensors themselves remain BF16.
+    numerator = denominator = 0.
+    for output,target in zip(outputs,reference['targets'],strict=True):
+        numerator += (output.float()-target.float()).square().double().sum().item()
+        denominator += target.float().square().double().sum().item()
+    assert denominator > 0 and numerator >= 0
+    report = dict(local_mse=numerator/outputs.numel(),local_nmse=numerator/denominator,
+        squared_error_sum=numerator,target_energy_sum=denominator,elements=outputs.numel(),
+        protocol=protocol,prefix_input_exact_match=True,compact_stage=str(a.compact_stage),fit=False)
+    a.output.parent.mkdir(parents=True,exist_ok=True)
+    a.output.write_text(json.dumps(report,indent=2)+'\n')
+    print('LOCAL_MSE_COMPLETE',json.dumps(report),flush=True)
+
+
+if __name__ == '__main__':
+    main()