Publish credential-free structural-smoke runner

config/benching/fable-router-training-campaign.v1.json

@@ -96,12 +96,100 @@
   },
   "optimizerAdmission": {
     "requiredBeforeStageA": true,
-    "steps": 2,
+    "steps": 8,
+    "rowsPerLane": 4,
+    "maximumTokens": 320,
+    "coverageStrategy": "four deterministic length-quantile rows per lane; cumulative gate update required across the eight-step smoke",
     "learningRate": 0.0002,
+    "gradientLossScale": 1024.0,
+    "donorInputNormalization": {
+      "mode": "donor_rms",
+      "epsilon": 1e-06,
+      "scope": "router_and_frozen_experts_only",
+      "sidecars": {
+        "kat-coder-v25-dev-q4km": {
+          "path": "artifacts/kat-coder-v25-dev-post-attention-rmsnorm.safetensors",
+          "bytes": 126520,
+          "sha256": "fc300a50b5c33fdf9a95af4975d58250c8566e1d504c37d99ee1ac93a413da04",
+          "referenceClass": "Qwen3_5RMSNorm",
+          "storedWeightTransform": "one_plus_stored_delta"
+        },
+        "ornith10-35b-q4km": {
+          "path": "artifacts/ornith10-35b-post-attention-rmsnorm.safetensors",
+          "bytes": 126424,
+          "sha256": "9ab2a3f10303fe2fe164940010955d2e2eec4684d2f4589353c494497bd05a18",
+          "referenceClass": "Qwen3_5RMSNorm",
+          "storedWeightTransform": "one_plus_stored_delta"
+        },
+        "qwen35-35b-base-q4km": {
+          "path": "artifacts/qwen35-35b-base-post-attention-rmsnorm.safetensors",
+          "bytes": 126504,
+          "sha256": "5f93344804e0bfecf02c20357619c558d7f9142d77e61b0846f0b11ef5282401",
+          "referenceClass": "Qwen3_5RMSNorm",
+          "storedWeightTransform": "one_plus_stored_delta"
+        },
+        "qwen36-35b-base-q4km": {
+          "path": "artifacts/qwen36-35b-base-post-attention-rmsnorm.safetensors",
+          "bytes": 126504,
+          "sha256": "382c973b6b62e03e39f250732b994bd30ed16ef46344a8e872bb4fc4a6b24ecc",
+          "referenceClass": "Qwen3_5RMSNorm",
+          "storedWeightTransform": "one_plus_stored_delta"
+        }
+      }
+    },
     "gradientClipNorm": 1.0,
     "counterfactualLayer": 29,
     "counterfactualCandidates": [0, 1, 8, 16],
     "counterfactualScale": 0.025,
+    "tokenizerContract": {
+      "hostRevision": "72d68fcd4b2b91749d2d6a71a0fdf315fe1704c8",
+      "transformers5ReferenceClass": "TokenizersBackend",
+      "portableLoader": "PreTrainedTokenizerFast",
+      "padTokenId": 124893,
+      "selectedRows": [
+        {
+          "id": "reasoning:fd42e6013f2f0bcbb570ef95f9a2fcb33156f3c3b197e2b8a2448bf99a20873d",
+          "lane": "host_preservation",
+          "tokens": 264
+        },
+        {
+          "id": "reasoning:bda1eef534240e26343576ad40f755bd57006b95b1a72da5ddcfa7d97cb73710",
+          "lane": "host_preservation",
+          "tokens": 294
+        },
+        {
+          "id": "reasoning:a6ea89c9d196768b04e69a82d8b3c4d49bd14485a2be4aa15ac4068e17f17cc6",
+          "lane": "host_preservation",
+          "tokens": 306
+        },
+        {
+          "id": "reasoning:c518a5503bc6c33a4f3e26a2b519b90c42a8a6e11934c80a2ba9fad386b81c22",
+          "lane": "host_preservation",
+          "tokens": 315
+        },
+        {
+          "id": "agent:480ed7c16d7fbc42f787e050bcb7ea4e0cb17eea06a899d543b4575216620a88:1",
+          "lane": "verified_expert",
+          "tokens": 48
+        },
+        {
+          "id": "agent:66244eb518816ac398c00b351d61fe53e26e279c5d4bf756954fd323669fc650:2",
+          "lane": "verified_expert",
+          "tokens": 204
+        },
+        {
+          "id": "agent:35d278d1ae43f2d93288060777dcb14a0a7b5eadf88c0a0287df367096a1c1fa:4",
+          "lane": "verified_expert",
+          "tokens": 260
+        },
+        {
+          "id": "agent:92d464ccdf4cea7bf0f3e04060492f317c99926d2071f19dd89f8eef10372aa8:5",
+          "lane": "verified_expert",
+          "tokens": 320
+        }
+      ],
+      "inputIdsSignatureSha256": "5b65e5dc5e00963a8fa2e639389ba0cbea816960296d42698e2f7116412cf24a"
+    },
     "memoryProof": {
       "path": "downloads/audits/fable-router-full-bank-training-memory-proof/result.json",
       "sha256": "64de6936e05e9f1d24df325fc1c2bf2bbb2e5109a45f888e940e3d366adce706",
@@ -117,12 +205,52 @@
       "four_independent_counterfactual_candidates",
       "positive_benefit_and_host_only_targets_present",
       "finite_sft_kl_ranking_and_route_cost_losses",
+      "loss_scaled_backward_with_preclip_unscale",
+      "donor_norm_equation_matches_architecture",
+      "optimizer_checkpoint_step_count_matches_smoke",
       "all_30_router_gates_updated",
+      "all_30_router_residuals_numerically_effective",
       "expert_scales_bounded_by_stage_a_maximum",
       "router_and_optimizer_checkpoint_persisted_privately"
     ]
   },
   "training": {
+    "gradientLossScale": 1024.0,
+    "donorInputNormalization": {
+      "mode": "donor_rms",
+      "epsilon": 1e-06,
+      "scope": "router_and_frozen_experts_only",
+      "sidecars": {
+        "kat-coder-v25-dev-q4km": {
+          "path": "artifacts/kat-coder-v25-dev-post-attention-rmsnorm.safetensors",
+          "bytes": 126520,
+          "sha256": "fc300a50b5c33fdf9a95af4975d58250c8566e1d504c37d99ee1ac93a413da04",
+          "referenceClass": "Qwen3_5RMSNorm",
+          "storedWeightTransform": "one_plus_stored_delta"
+        },
+        "ornith10-35b-q4km": {
+          "path": "artifacts/ornith10-35b-post-attention-rmsnorm.safetensors",
+          "bytes": 126424,
+          "sha256": "9ab2a3f10303fe2fe164940010955d2e2eec4684d2f4589353c494497bd05a18",
+          "referenceClass": "Qwen3_5RMSNorm",
+          "storedWeightTransform": "one_plus_stored_delta"
+        },
+        "qwen35-35b-base-q4km": {
+          "path": "artifacts/qwen35-35b-base-post-attention-rmsnorm.safetensors",
+          "bytes": 126504,
+          "sha256": "5f93344804e0bfecf02c20357619c558d7f9142d77e61b0846f0b11ef5282401",
+          "referenceClass": "Qwen3_5RMSNorm",
+          "storedWeightTransform": "one_plus_stored_delta"
+        },
+        "qwen36-35b-base-q4km": {
+          "path": "artifacts/qwen36-35b-base-post-attention-rmsnorm.safetensors",
+          "bytes": 126504,
+          "sha256": "382c973b6b62e03e39f250732b994bd30ed16ef46344a8e872bb4fc4a6b24ecc",
+          "referenceClass": "Qwen3_5RMSNorm",
+          "storedWeightTransform": "one_plus_stored_delta"
+        }
+      }
+    },
     "stages": [
       {"name": "A-host-anchor", "steps": 200},
       {"name": "B-benefit-gated-routing", "steps": 600},

training/fable_router_hybrid.py

@@ -96,6 +96,13 @@ class RouteTrace:
     selected_weights: torch.Tensor
     off_probability: torch.Tensor
     active_scale: torch.Tensor
+    host_std: torch.Tensor
+    donor_input_std: torch.Tensor
+    expert_std: torch.Tensor
+    normalization_factor: torch.Tensor
+    residual_std: torch.Tensor
+    residual_max_abs: torch.Tensor
+    post_add_changed: torch.Tensor
 
 
 class FrozenExpertRouterBlock(nn.Module):
@@ -110,6 +117,8 @@ class FrozenExpertRouterBlock(nn.Module):
         top_k: int = 2,
         initial_scale: float = 0.005,
         maximum_scale: float = 0.1,
+        donor_input_normalization: str = "none",
+        donor_norm_eps: float = 1e-6,
     ):
         super().__init__()
         if len(expert_ids) != 32 or len(set(expert_ids)) != 32:
@@ -124,6 +133,13 @@ class FrozenExpertRouterBlock(nn.Module):
         self.expert_scale = nn.Parameter(torch.tensor(inverse_softplus(initial_scale)))
         self.top_k = top_k
         self.maximum_scale = float(maximum_scale)
+        if donor_input_normalization not in {"none", "unit_rms", "donor_rms"}:
+            raise ValueError("unsupported donor input normalization")
+        self.donor_input_normalization = donor_input_normalization
+        self.donor_norm_eps = float(donor_norm_eps)
+        self.register_buffer("donor_norm_weight", torch.ones(hidden_size), persistent=False)
+        self._donor_norm_loaded = donor_input_normalization != "donor_rms"
+        self.donor_norm_weight_transform: str | None = None
         self.enabled = True
         self.checkpoint_enabled = False
         self._forced_expert: int | None = None
@@ -154,6 +170,26 @@ class FrozenExpertRouterBlock(nn.Module):
         with torch.no_grad():
             self.router.gate.weight.copy_(weight.to(self.router.gate.weight))
 
+    def load_donor_norm(
+        self,
+        weight: torch.Tensor,
+        *,
+        device: torch.device,
+        dtype: torch.dtype,
+        stored_weight_transform: str,
+    ) -> None:
+        if tuple(weight.shape) != tuple(self.donor_norm_weight.shape):
+            raise ValueError(f"donor RMSNorm shape mismatch: {tuple(weight.shape)}")
+        if stored_weight_transform == "one_plus_stored_delta":
+            effective_weight = 1.0 + weight.float()
+        elif stored_weight_transform == "identity":
+            effective_weight = weight.float()
+        else:
+            raise ValueError(f"unsupported donor RMSNorm stored-weight transform: {stored_weight_transform}")
+        self.donor_norm_weight = effective_weight.to(device=device, dtype=dtype).contiguous()
+        self.donor_norm_weight_transform = stored_weight_transform
+        self._donor_norm_loaded = True
+
     def materialize_experts(
         self,
         bank_path: Path,
@@ -199,7 +235,15 @@ class FrozenExpertRouterBlock(nn.Module):
             return hidden_states
         original_shape = hidden_states.shape
         flat = hidden_states.reshape(-1, original_shape[-1])
-        logits = self.router(flat)
+        donor_input = flat
+        if self.donor_input_normalization in {"unit_rms", "donor_rms"}:
+            if not self._donor_norm_loaded:
+                raise RuntimeError("exact donor RMSNorm weight was not loaded")
+            norm_weight = self.donor_norm_weight.float() if self.donor_input_normalization == "donor_rms" else None
+            donor_input = F.rms_norm(
+                flat.float(), (flat.shape[-1],), weight=norm_weight, eps=self.donor_norm_eps
+            ).to(flat.dtype)
+        logits = self.router(donor_input)
 
         if self._forced_expert is not None:
             selected = torch.full(
@@ -215,12 +259,29 @@ class FrozenExpertRouterBlock(nn.Module):
             off_probability = probabilities[:, -1]
             scale = torch.clamp(F.softplus(self.expert_scale), max=self.maximum_scale).to(flat.dtype)
 
-        expert_output = self._expert_output(flat, selected, weights)
+        expert_output = self._expert_output(donor_input, selected, weights)
         host_std = flat.float().std().detach().clamp_min(1e-6)
+        donor_input_std = donor_input.float().std().detach().clamp_min(1e-6)
         expert_std = expert_output.float().std().detach().clamp_min(1e-6)
-        expert_output = expert_output * torch.clamp(host_std / expert_std, max=2.0).to(flat.dtype)
-        self.last_trace = RouteTrace(logits, selected, weights, off_probability, scale)
-        return hidden_states + (scale * expert_output).reshape(original_shape)
+        normalization = torch.clamp(host_std / expert_std, max=2.0).to(flat.dtype)
+        expert_output = expert_output * normalization
+        residual = scale * expert_output
+        routed_flat = flat + residual
+        self.last_trace = RouteTrace(
+            logits,
+            selected,
+            weights,
+            off_probability,
+            scale,
+            host_std,
+            donor_input_std,
+            expert_std,
+            normalization.detach(),
+            residual.float().std().detach(),
+            residual.float().abs().max().detach(),
+            torch.count_nonzero((routed_flat - flat).detach()),
+        )
+        return routed_flat.reshape(original_shape)
 
 
 class AugmentedHostLayer(nn.Module):

training/run_fable_router_full_bank_fit.py

@@ -9,8 +9,10 @@ from __future__ import annotations
 
 import argparse
 import json
+import multiprocessing
 import os
 import platform
+import queue
 import shutil
 import sys
 import time
@@ -20,9 +22,9 @@ from pathlib import Path
 from typing import Any
 
 import torch
-from huggingface_hub import HfApi, hf_hub_download
+from huggingface_hub import HfApi, constants as hf_constants, hf_hub_download
 from safetensors.torch import load_file, save_file
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import AutoModelForCausalLM, PreTrainedTokenizerFast
 
 HERE = Path(__file__).resolve().parent
 if str(HERE) not in sys.path:
@@ -58,8 +60,151 @@ def now() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
+def _latest_incomplete(started_at: float) -> Path | None:
+    root = Path(hf_constants.HF_HUB_CACHE)
+    if not root.is_dir():
+        return None
+    candidates = [
+        path
+        for path in root.rglob("*.incomplete")
+        if path.is_file() and path.stat().st_mtime >= started_at - 5
+    ]
+    return max(candidates, key=lambda path: path.stat().st_mtime, default=None)
+
+
+def _download_worker(
+    outcome: Any,
+    repo: str,
+    revision: str,
+    filename: str,
+    repo_type: str,
+    token: str | None,
+) -> None:
+    try:
+        path = hf_hub_download(
+            repo_id=repo,
+            revision=revision,
+            filename=filename,
+            repo_type=repo_type,
+            token=token,
+        )
+        outcome.put({"path": str(path)})
+    except BaseException as exc:
+        outcome.put({"errorType": type(exc).__name__, "error": str(exc)})
+
+
+def _download_once_with_progress(
+    repo: str,
+    revision: str,
+    filename: str,
+    repo_type: str,
+    token: str | None,
+    attempt: int,
+) -> Path:
+
+    started_at = time.time()
+    previous_bytes = 0
+    previous_at = started_at
+    context = multiprocessing.get_context("spawn")
+    outcome = context.Queue()
+    transfer_mode = "xet" if attempt % 2 else "http"
+    transfer_keys = ("HF_HUB_DISABLE_XET", "HF_XET_HIGH_PERFORMANCE", "HF_XET_NUM_CONCURRENT_RANGE_GETS")
+    previous_transfer_env = {key: os.environ.get(key) for key in transfer_keys}
+    if transfer_mode == "xet":
+        os.environ.pop("HF_HUB_DISABLE_XET", None)
+        os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"
+        os.environ["HF_XET_NUM_CONCURRENT_RANGE_GETS"] = "32"
+    else:
+        os.environ["HF_HUB_DISABLE_XET"] = "1"
+        os.environ.pop("HF_XET_HIGH_PERFORMANCE", None)
+        os.environ.pop("HF_XET_NUM_CONCURRENT_RANGE_GETS", None)
+    process = context.Process(
+        target=_download_worker,
+        args=(outcome, repo, revision, filename, repo_type, token),
+        name=f"hub-download-{attempt}",
+        daemon=True,
+    )
+    try:
+        process.start()
+    finally:
+        for key, value in previous_transfer_env.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+    print(f"download-attempt {filename} attempt={attempt} transferMode={transfer_mode}", flush=True)
+    consecutive_slow_samples = 0
+    while process.is_alive():
+        process.join(timeout=15)
+        sampled_at = time.time()
+        incomplete = _latest_incomplete(started_at)
+        size = incomplete.stat().st_size if incomplete is not None else previous_bytes
+        if size == previous_bytes:
+            if sampled_at - started_at >= 120 and sampled_at - previous_at >= 90:
+                print(
+                    f"download-stalled-restart {filename} attempt={attempt} "
+                    f"bytes={size} elapsedSeconds={round(sampled_at-started_at)}",
+                    flush=True,
+                )
+                process.terminate()
+                process.join(timeout=30)
+                if process.is_alive():
+                    process.kill()
+                    process.join()
+                raise RuntimeError(f"download made no progress for 90 seconds for {filename}")
+            continue
+        rate = (size - previous_bytes) / max(sampled_at - previous_at, 0.001) / (1024 * 1024)
+        print(
+            f"download-progress {filename} attempt={attempt} bytes={size} "
+            f"deltaBytes={size - previous_bytes} rateMiBs={rate:.2f} "
+            f"elapsedSeconds={round(sampled_at - started_at)} transferMode={transfer_mode}",
+            flush=True,
+        )
+        previous_bytes = size
+        previous_at = sampled_at
+        if sampled_at - started_at >= 120 and rate < 1.0:
+            consecutive_slow_samples += 1
+        else:
+            consecutive_slow_samples = 0
+        if consecutive_slow_samples >= 4:
+            print(
+                f"download-slow-restart {filename} attempt={attempt} "
+                f"rateMiBs={rate:.2f} bytes={size} elapsedSeconds={round(sampled_at-started_at)}",
+                flush=True,
+            )
+            process.terminate()
+            process.join(timeout=30)
+            if process.is_alive():
+                process.kill()
+                process.join()
+            raise RuntimeError(f"sustained download rate below 1 MiB/s for {filename}")
+    process.join()
+    try:
+        observed = outcome.get(timeout=2)
+    except queue.Empty as exc:
+        raise RuntimeError(f"download worker exited {process.exitcode} without an outcome for {filename}") from exc
+    if "error" in observed:
+        raise RuntimeError(f"{observed.get('errorType')}: {observed['error']}")
+    return Path(str(observed["path"]))
+
+
 def download(repo: str, revision: str, filename: str, repo_type: str, token: str | None) -> Path:
-    return Path(hf_hub_download(repo_id=repo, revision=revision, filename=filename, repo_type=repo_type, token=token))
+    last_error: Exception | None = None
+    for attempt in range(1, 7):
+        try:
+            path = _download_once_with_progress(repo, revision, filename, repo_type, token, attempt)
+            print(f"download-complete {filename} attempt={attempt}", flush=True)
+            return path
+        except Exception as exc:
+            last_error = exc
+            print(
+                f"download-retry {filename} attempt={attempt}/6 error={type(exc).__name__}: {str(exc)[:300]}",
+                flush=True,
+            )
+            if attempt < 6:
+                time.sleep(min(20 * attempt, 90))
+    assert last_error is not None
+    raise last_error
 
 
 def verify_authorization(campaign_path: Path, result: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any]]:
@@ -169,7 +314,10 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     result["curriculumArtifact"] = verify_file(train_path, int(train_cfg["bytes"]), train_cfg["sha256"])
 
     host = config["host"]
-    tokenizer = AutoTokenizer.from_pretrained(host["repo"], revision=host["revision"], token=token, trust_remote_code=True, fix_mistral_regex=True)
+    tokenizer = PreTrainedTokenizerFast.from_pretrained(
+        host["repo"], revision=host["revision"], token=token, trust_remote_code=True
+    )
+    result["tokenizerLoader"] = "PreTrainedTokenizerFast"
     rows = (
         select_complete_rows(train_path, tokenizer, int(admission["maximumTokens"]))
         if args.profile == "resident"

training/run_fable_router_optimizer_smoke.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import hashlib
 import json
 import os
 import platform
@@ -16,7 +17,7 @@ from typing import Any
 import torch
 import torch.nn.functional as F
 from safetensors.torch import load_file, save_file
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import AutoModelForCausalLM, PreTrainedTokenizerFast
 
 HERE = Path(__file__).resolve().parent
 if str(HERE) not in sys.path:
@@ -97,9 +98,36 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     result["curriculumArtifact"] = verify_file(train_path, int(train_cfg["bytes"]), train_cfg["sha256"])
 
     host = config["host"]
-    tokenizer = AutoTokenizer.from_pretrained(host["repo"], revision=host["revision"], token=token, trust_remote_code=True, fix_mistral_regex=True)
-    rows = select_complete_rows(train_path, tokenizer, 320)
+    # The pinned revision names the Transformers 5 TokenizersBackend class, which
+    # is not registered by the pinned Kaggle Transformers 4 runtime.  Load the
+    # same tokenizer.json explicitly through its version-portable fast base.
+    tokenizer = PreTrainedTokenizerFast.from_pretrained(
+        host["repo"], revision=host["revision"], token=token, trust_remote_code=True
+    )
+    result["tokenizerLoader"] = "PreTrainedTokenizerFast"
+    rows = select_complete_rows(
+        train_path,
+        tokenizer,
+        int(optimizer_contract["maximumTokens"]),
+        rows_per_lane=int(optimizer_contract["rowsPerLane"]),
+    )
     result["rows"] = [{"id": row["id"], "lane": row["lane"], "tokens": len(row["inputIds"])} for row in rows]
+    tokenizer_contract = optimizer_contract["tokenizerContract"]
+    token_payload = json.dumps(rows, sort_keys=True, separators=(",", ":")).encode()
+    token_signature = hashlib.sha256(token_payload).hexdigest()
+    result["tokenizerContract"] = {
+        "loader": "PreTrainedTokenizerFast",
+        "padTokenId": int(tokenizer.pad_token_id),
+        "inputIdsSignatureSha256": token_signature,
+        "expectedInputIdsSignatureSha256": tokenizer_contract["inputIdsSignatureSha256"],
+        "passed": (
+            token_signature == tokenizer_contract["inputIdsSignatureSha256"]
+            and int(tokenizer.pad_token_id) == int(tokenizer_contract["padTokenId"])
+            and result["rows"] == tokenizer_contract["selectedRows"]
+        ),
+    }
+    if not result["tokenizerContract"]["passed"]:
+        raise RuntimeError("portable tokenizer output differs from the pinned Transformers 5 reference")
     device = torch.device("cuda:0")
     dtype = compute_dtype(result["gpu"])
     torch.cuda.reset_peak_memory_stats(device)
@@ -113,12 +141,45 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     model.enable_input_require_grads()
     warm_state = load_file(str(warm_path), device="cpu")
     blocks: list[FrozenExpertRouterBlock] = []
+    donor_norm = optimizer_contract["donorInputNormalization"]
+    result["donorInputNormalization"] = donor_norm
+    norm_state = None
+    if donor_norm["mode"] == "donor_rms":
+        if args.norm_sidecar is None:
+            raise RuntimeError("exact donor RMSNorm mode requires --norm-sidecar")
+        sidecar = donor_norm["sidecars"].get(args.bank)
+        if sidecar is None:
+            raise RuntimeError(f"no exact donor RMSNorm sidecar is frozen for {args.bank}")
+        if sidecar.get("referenceClass") != "Qwen3_5RMSNorm":
+            raise RuntimeError("donor RMSNorm sidecar is not bound to Qwen3_5RMSNorm")
+        if sidecar.get("storedWeightTransform") != "one_plus_stored_delta":
+            raise RuntimeError("Qwen3_5RMSNorm requires one_plus_stored_delta")
+        norm_path = args.norm_sidecar.resolve()
+        result["donorNormArtifact"] = verify_file(norm_path, int(sidecar["bytes"]), sidecar["sha256"])
+        result["donorNormEquation"] = {
+            "referenceClass": sidecar["referenceClass"],
+            "storedWeightTransform": sidecar["storedWeightTransform"],
+            "equation": "rms_unit(x) * (1 + stored_weight)",
+            "passed": True,
+        }
+        norm_state = load_file(str(norm_path), device="cpu")
     for layer in range(30):
-        block = FrozenExpertRouterBlock(selected_expert_ids(bank_definition, layer), top_k=2, initial_scale=0.005, maximum_scale=0.025)
+        block = FrozenExpertRouterBlock(
+            selected_expert_ids(bank_definition, layer), top_k=2,
+            initial_scale=0.005, maximum_scale=0.025,
+            donor_input_normalization=donor_norm["mode"],
+            donor_norm_eps=float(donor_norm["epsilon"]),
+        )
         attach_router_block(model, layer, block)
         block.router.to(device=device, dtype=torch.float32)
         block.expert_scale.data = block.expert_scale.data.to(device=device)
         block.materialize_experts(bank_path, layer, device=torch.device("cpu"), dtype=dtype)
+        if norm_state is not None:
+            block.load_donor_norm(
+                norm_state[f"model.layers.{layer}.post_attention_layernorm.weight"],
+                device=device, dtype=dtype,
+                stored_weight_transform=sidecar["storedWeightTransform"],
+            )
         block.load_router_warmstart(warm_state[f"layers.{layer}.router.gate.weight"])
         block.checkpoint_enabled = True
         blocks.append(block)
@@ -130,6 +191,10 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     before_state = router_state_dict(model)
     parameters = [parameter for parameter in model.parameters() if parameter.requires_grad]
     optimizer = torch.optim.AdamW(parameters, lr=float(optimizer_contract["learningRate"]), weight_decay=0.0)
+    gradient_loss_scale = float(optimizer_contract["gradientLossScale"])
+    if not gradient_loss_scale >= 1.0:
+        raise RuntimeError("optimizer gradient loss scale must be at least one")
+    result["gradientLossScale"] = gradient_loss_scale
 
     metrics = []
     positive_and_off = False
@@ -158,7 +223,7 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
             for column, local_expert in enumerate(candidates):
                 mapped[column_targets == column] = local_expert
             positive = mapped != blocks[probe_layer].off_class_index
-            positive_and_off = bool(positive.any() and (~positive).any())
+            positive_and_off = positive_and_off or bool(positive.any() and (~positive).any())
             discovery = {
                 "layer": probe_layer,
                 "candidates": candidates,
@@ -194,7 +259,37 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
         total = routed.loss + kl_weight * kl + ranking_loss + 0.015 * route_cost
         if not torch.isfinite(total):
             raise RuntimeError("optimizer smoke produced a non-finite objective")
-        total.backward()
+        layer_forward_diagnostics = []
+        for layer, block in enumerate(blocks):
+            trace = block.last_trace
+            if trace is None:
+                raise RuntimeError(f"layer {layer} router trace is missing")
+            layer_forward_diagnostics.append({
+                "layer": layer,
+                "logitsDtype": str(trace.logits.dtype),
+                "selectedWeightsDtype": str(trace.selected_weights.dtype),
+                "selectedUniqueExperts": int(torch.unique(trace.selected_experts).numel()),
+                "meanSelectedWeight": float(trace.selected_weights.float().mean()),
+                "meanOffProbability": float(trace.off_probability.float().mean()),
+                "activeScale": float(trace.active_scale.float()),
+                "hostStd": float(trace.host_std.float()),
+                "donorInputStd": float(trace.donor_input_std.float()),
+                "expertStd": float(trace.expert_std.float()),
+                "normalizationFactor": float(trace.normalization_factor.float()),
+                "residualStd": float(trace.residual_std.float()),
+                "residualMaxAbs": float(trace.residual_max_abs.float()),
+                "postAddChanged": int(trace.post_add_changed),
+            })
+        # Scaling the scalar objective before backpropagation is numerically
+        # neutral after unscaling the FP32 router gradients, while preventing
+        # small router signals from underflowing as they traverse the frozen
+        # FP16 residual branch.  Ornith layer 2 exposed this exact failure:
+        # its scale gradient survived but its gate gradient was identically
+        # zero across all eight deterministic rows.
+        (total * gradient_loss_scale).backward()
+        for parameter in parameters:
+            if parameter.grad is not None:
+                parameter.grad.div_(gradient_loss_scale)
         layer_gradients = []
         for layer, block in enumerate(blocks):
             gate_grad = block.router.gate.weight.grad
@@ -230,6 +325,7 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
             "totalLoss": float(total.detach()),
             "gradientNorm": grad_norm,
             "discovery": discovery,
+            "layerForwardDiagnostics": layer_forward_diagnostics,
             "layerGradients": layer_gradients,
             "layerUpdates": layer_updates,
         })
@@ -238,6 +334,17 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
 
     if not positive_and_off:
         raise RuntimeError("counterfactual optimizer smoke did not produce both expert and host-only targets")
+    effective_layers = sorted({
+        int(row["layer"])
+        for step in metrics
+        for row in step["layerForwardDiagnostics"]
+        if int(row["postAddChanged"]) > 0
+    })
+    result["effectiveResidualLayers"] = effective_layers
+    if effective_layers != list(range(30)):
+        raise RuntimeError(
+            f"not every router residual changed the host activation: {effective_layers}"
+        )
     after_state = router_state_dict(model)
     changed_layers = []
     update_diagnostics = []
@@ -260,8 +367,12 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     output = Path(result["output"])
     checkpoint = output / "router-checkpoint.safetensors"
     optimizer_path = output / "optimizer.pt"
-    save_file(after_state, str(checkpoint), metadata={"autonoma": "non-routing-optimizer-smoke", "bank": args.bank})
-    torch.save({"optimizer": optimizer.state_dict(), "completedSteps": 2, "bank": args.bank}, optimizer_path)
+    completed_steps = len(metrics)
+    save_file(after_state, str(checkpoint), metadata={
+        "autonoma": "non-routing-optimizer-smoke", "bank": args.bank,
+        "completed_steps": str(completed_steps),
+    })
+    torch.save({"optimizer": optimizer.state_dict(), "completedSteps": completed_steps, "bank": args.bank}, optimizer_path)
     result["steps"] = metrics
     result["updateGate"] = {
         "changedRouterLayers": changed_layers,
@@ -270,6 +381,7 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     }
     result["checkpoint"] = {"path": str(checkpoint), "bytes": checkpoint.stat().st_size, "sha256": sha256(checkpoint)}
     result["optimizerCheckpoint"] = {"path": str(optimizer_path), "bytes": optimizer_path.stat().st_size, "sha256": sha256(optimizer_path)}
+    result["optimizerState"] = {"completedSteps": completed_steps, "bank": args.bank}
     result["runtime"] = {
         "seconds": time.perf_counter() - started,
         "peakAllocatedVramMiB": torch.cuda.max_memory_allocated(device) / 2**20,
@@ -290,6 +402,7 @@ def main() -> int:
     parser.add_argument("--bank", required=True)
     parser.add_argument("--curriculum-path", type=Path, required=True)
     parser.add_argument("--memory-proof", type=Path, required=True)
+    parser.add_argument("--norm-sidecar", type=Path)
     parser.add_argument("--work-dir", type=Path, default=Path("/content/autonoma-fable-training"))
     args = parser.parse_args()
     if not args.owner_execute:

training/run_fable_router_stage_a_chunk.py

@@ -54,6 +54,7 @@ MAXIMUM_TOKENS = 2048
 MAXIMUM_CHUNK_STEPS = 25
 LEARNING_RATE = 2e-4
 GRADIENT_CLIP = 1.0
+GRADIENT_LOSS_SCALE = 1024.0
 REPLAY_MAXIMUM = 4096
 
 
@@ -292,9 +293,29 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     train_cfg = config["curriculum"]["sftTrain"]
     train_path = args.curriculum_path.resolve()
     result["curriculumArtifact"] = verify_file(train_path, int(train_cfg["bytes"]), train_cfg["sha256"])
+    donor_norm = campaign["training"]["donorInputNormalization"]
+    if donor_norm["mode"] != "donor_rms" or args.norm_sidecar is None:
+        raise RuntimeError("Stage A requires an exact donor RMSNorm sidecar")
+    sidecar = donor_norm["sidecars"].get(args.bank)
+    if sidecar is None:
+        raise RuntimeError(f"no exact donor RMSNorm sidecar is frozen for {args.bank}")
+    if sidecar.get("referenceClass") != "Qwen3_5RMSNorm" or sidecar.get("storedWeightTransform") != "one_plus_stored_delta":
+        raise RuntimeError("Stage A donor norm is not architecture-faithful Qwen3_5RMSNorm")
+    norm_path = args.norm_sidecar.resolve()
+    result["donorInputNormalization"] = donor_norm
+    result["donorNormArtifact"] = verify_file(norm_path, int(sidecar["bytes"]), sidecar["sha256"])
+    result["donorNormEquation"] = {
+        "referenceClass": sidecar["referenceClass"],
+        "storedWeightTransform": sidecar["storedWeightTransform"],
+        "equation": "rms_unit(x) * (1 + stored_weight)",
+        "passed": True,
+    }
+    norm_state = load_file(str(norm_path), device="cpu")
 
     host = config["host"]
-    tokenizer = AutoTokenizer.from_pretrained(host["repo"], revision=host["revision"], token=token, trust_remote_code=True, fix_mistral_regex=True)
+    tokenizer = AutoTokenizer.from_pretrained(
+        host["repo"], revision=host["revision"], token=token, trust_remote_code=True
+    )
     pools = load_row_pools(train_path, tokenizer)
     lane_schedule = frozen_lane_schedule(curriculum, SEED)
     rows = scheduled_rows(pools, lane_schedule, args.start_step, end_step)
@@ -314,11 +335,22 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     warm_state = load_file(str(warm_path), device="cpu")
     blocks: list[FrozenExpertRouterBlock] = []
     for layer in range(30):
-        block = FrozenExpertRouterBlock(selected_expert_ids(definition, layer), top_k=2, initial_scale=0.005, maximum_scale=0.025)
+        block = FrozenExpertRouterBlock(
+            selected_expert_ids(definition, layer), top_k=2,
+            initial_scale=0.005, maximum_scale=0.025,
+            donor_input_normalization=donor_norm["mode"],
+            donor_norm_eps=float(donor_norm["epsilon"]),
+        )
         attach_router_block(model, layer, block)
         block.router.to(device=device, dtype=torch.float32)
         block.expert_scale.data = block.expert_scale.data.to(device=device)
         block.materialize_experts(bank_path, layer, device=torch.device("cpu"), dtype=dtype)
+        block.load_donor_norm(
+            norm_state[f"model.layers.{layer}.post_attention_layernorm.weight"],
+            device=device,
+            dtype=dtype,
+            stored_weight_transform=sidecar["storedWeightTransform"],
+        )
         block.load_router_warmstart(warm_state[f"layers.{layer}.router.gate.weight"])
         block.checkpoint_enabled = True
         blocks.append(block)
@@ -414,7 +446,10 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
         )
         if not torch.isfinite(total):
             raise RuntimeError("Stage-A chunk produced a non-finite objective")
-        total.backward()
+        (total * GRADIENT_LOSS_SCALE).backward()
+        for parameter in parameters:
+            if parameter.grad is not None:
+                parameter.grad.div_(GRADIENT_LOSS_SCALE)
         gradient_norm = float(torch.nn.utils.clip_grad_norm_(parameters, GRADIENT_CLIP))
         optimizer.step()
         maximum_scale = max(float(F.softplus(block.expert_scale).detach()) for block in blocks)
@@ -483,6 +518,7 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
         "assistant_only_prefix_stable_supervision": True,
         "complete_rows_without_truncation": True,
         "host_and_experts_frozen": True,
+        "donor_norm_equation_matches_architecture": True,
         "deterministic_lane_and_expert_coverage": True,
         "counterfactual_off_class_and_positive_replay": True,
         "stage_a_scale_cap": True,
@@ -498,6 +534,7 @@ def main() -> int:
     parser.add_argument("--curriculum-path", type=Path, required=True)
     parser.add_argument("--optimizer-proof", type=Path, required=True)
     parser.add_argument("--optimizer-consolidation", type=Path, required=True)
+    parser.add_argument("--norm-sidecar", type=Path, required=True)
     parser.add_argument("--start-step", type=int, required=True)
     parser.add_argument("--steps", type=int, default=MAXIMUM_CHUNK_STEPS)
     parser.add_argument("--resume-dir", type=Path)

training/run_fable_router_structural_smoke.py

@@ -34,7 +34,7 @@ import torch
 import torch.nn.functional as F
 from huggingface_hub import HfApi, hf_hub_download
 from safetensors.torch import load_file, save_file
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import AutoModelForCausalLM, PreTrainedTokenizerFast
 
 HERE = Path(__file__).resolve().parent
 if str(HERE) not in sys.path:
@@ -84,9 +84,16 @@ def render_and_tokenize(tokenizer: Any, messages: list[dict[str, Any]]) -> list[
     return list(tokenizer(rendered, add_special_tokens=False)["input_ids"])
 
 
-def select_complete_rows(path: Path, tokenizer: Any, maximum_tokens: int) -> list[dict[str, Any]]:
+def select_complete_rows(
+    path: Path,
+    tokenizer: Any,
+    maximum_tokens: int,
+    rows_per_lane: int = 1,
+) -> list[dict[str, Any]]:
+    if rows_per_lane < 1:
+        raise ValueError("rows_per_lane must be positive")
     wanted = ("host_preservation", "verified_expert")
-    best: dict[str, tuple[int, dict[str, Any], list[int]]] = {}
+    eligible: dict[str, list[tuple[int, str, dict[str, Any], list[int]]]] = {lane: [] for lane in wanted}
     for row in iter_jsonl(path):
         validate_curriculum_row(row, "train")
         lane = str(row["lane"])
@@ -95,16 +102,23 @@ def select_complete_rows(path: Path, tokenizer: Any, maximum_tokens: int) -> lis
         ids = render_and_tokenize(tokenizer, row["messages"])
         if len(ids) > maximum_tokens:
             continue
-        previous = best.get(lane)
-        if previous is None or len(ids) < previous[0]:
-            best[lane] = (len(ids), row, ids)
-    missing = sorted(set(wanted) - set(best))
+        eligible[lane].append((len(ids), str(row["id"]), row, ids))
+    missing = sorted(lane for lane in wanted if len(eligible[lane]) < rows_per_lane)
     if missing:
-        raise RuntimeError(f"no complete <= {maximum_tokens}-token rows for lanes {missing}")
-    return [
-        {"id": best[lane][1]["id"], "lane": lane, "inputIds": best[lane][2]}
-        for lane in wanted
-    ]
+        raise RuntimeError(
+            f"fewer than {rows_per_lane} complete <= {maximum_tokens}-token rows for lanes {missing}"
+        )
+    selected = []
+    for lane in wanted:
+        ordered = sorted(eligible[lane], key=lambda item: (item[0], item[1]))
+        if rows_per_lane == 1:
+            indexes = [0]
+        else:
+            indexes = [round(index * (len(ordered) - 1) / (rows_per_lane - 1)) for index in range(rows_per_lane)]
+        for index in indexes:
+            _, _, row, ids = ordered[index]
+            selected.append({"id": row["id"], "lane": lane, "inputIds": ids})
+    return selected
 
 
 def batch_rows(rows: list[dict[str, Any]], pad_token_id: int, device: torch.device) -> dict[str, torch.Tensor]:
@@ -247,10 +261,10 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     )
 
     host = config["host"]
-    tokenizer = AutoTokenizer.from_pretrained(
+    tokenizer = PreTrainedTokenizerFast.from_pretrained(
         host["repo"], revision=host["revision"], token=token, trust_remote_code=True,
-        fix_mistral_regex=True,
     )
+    result["tokenizerLoader"] = "PreTrainedTokenizerFast"
     rows = select_complete_rows(train_path, tokenizer, int(smoke["maximumTokens"]))
     result["retokenization"] = {
         "maximumTokens": int(smoke["maximumTokens"]),