Publish credential-free structural-smoke runner

training/fable_router_training_schedule.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Pure deterministic scheduling helpers for the frozen Fable router curriculum."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+import json
+import random
+from typing import Any, Iterable
+
+
+def canonical_seed(*parts: object) -> int:
+    payload = json.dumps(parts, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return int.from_bytes(hashlib.sha256(payload).digest()[:8], "big")
+
+
+def linear_anneal(initial: float, final: float, step: int, anneal_steps: int) -> float:
+    if anneal_steps <= 0:
+        return float(final)
+    progress = min(max(int(step), 0), int(anneal_steps)) / float(anneal_steps)
+    return float(initial) + (float(final) - float(initial)) * progress
+
+
+def benefit_margin(step: int, final_margin: float = 0.02) -> float:
+    if step <= 100:
+        return 0.0
+    return linear_anneal(0.0, final_margin, step - 100, 200)
+
+
+def route_cost_multiplier(step: int) -> float:
+    if step < 100:
+        return 0.0
+    return linear_anneal(0.0, 1.0, step - 100, 200)
+
+
+@dataclass(frozen=True)
+class StagePosition:
+    name: str
+    global_step: int
+    stage_step: int
+    stage_start: int
+    stage_end: int
+    router_scale_maximum: float
+    loop_negative_ratio: float
+
+
+def stage_position(curriculum: dict[str, Any], global_step: int) -> StagePosition:
+    if global_step < 0:
+        raise ValueError("global step must be non-negative")
+    start = 0
+    for stage in curriculum["curriculum"]:
+        end = start + int(stage["steps"])
+        if global_step < end:
+            return StagePosition(
+                name=str(stage["stage"]),
+                global_step=global_step,
+                stage_step=global_step - start,
+                stage_start=start,
+                stage_end=end,
+                router_scale_maximum=float(stage["routerScaleMaximum"]),
+                loop_negative_ratio=float(stage.get("loopNegativeRatio", 0.0)),
+            )
+        start = end
+    raise IndexError(f"global step {global_step} is outside the frozen {start}-step curriculum")
+
+
+def _mixture_counts(stage: dict[str, Any]) -> dict[str, int]:
+    steps = int(stage["steps"])
+    raw = {str(lane): float(weight) * steps for lane, weight in stage["mixture"].items()}
+    counts = {lane: int(value) for lane, value in raw.items()}
+    remainder = steps - sum(counts.values())
+    order = sorted(raw, key=lambda lane: (-(raw[lane] - counts[lane]), lane))
+    for lane in order[:remainder]:
+        counts[lane] += 1
+    if sum(counts.values()) != steps:
+        raise RuntimeError("stage mixture did not resolve to the exact declared step count")
+    return counts
+
+
+def frozen_lane_schedule(curriculum: dict[str, Any], seed: int) -> list[str]:
+    schedule: list[str] = []
+    for stage_index, stage in enumerate(curriculum["curriculum"]):
+        stage_rows = [lane for lane, count in _mixture_counts(stage).items() for _ in range(count)]
+        random.Random(canonical_seed(seed, stage_index, stage["stage"])).shuffle(stage_rows)
+        schedule.extend(stage_rows)
+    return schedule
+
+
+class ExpertCoverageSchedule:
+    """Yield four independent local expert candidates while covering every layer/bank row.
+
+    One eligible step probes exactly one source layer. Layers are visited round-robin.
+    Eight visits cover all 32 selected experts in that layer. Later 240-step cycles use
+    a new deterministic permutation, preserving exploration without changing cardinality.
+    """
+
+    def __init__(self, layers: int = 30, experts_per_layer: int = 32,
+                 candidates_per_step: int = 4, seed: int = 0):
+        if layers <= 0 or experts_per_layer <= 0 or candidates_per_step <= 0:
+            raise ValueError("coverage dimensions must be positive")
+        if experts_per_layer % candidates_per_step:
+            raise ValueError("experts per layer must be divisible by candidates per step")
+        self.layers = int(layers)
+        self.experts_per_layer = int(experts_per_layer)
+        self.candidates_per_step = int(candidates_per_step)
+        self.visits_per_layer = self.experts_per_layer // self.candidates_per_step
+        self.steps_per_cycle = self.layers * self.visits_per_layer
+        self.seed = int(seed)
+
+    def probe(self, eligible_step: int) -> tuple[int, list[int]]:
+        if eligible_step < 0:
+            raise ValueError("eligible step must be non-negative")
+        cycle, within = divmod(int(eligible_step), self.steps_per_cycle)
+        layer = within % self.layers
+        visit = within // self.layers
+        order = list(range(self.experts_per_layer))
+        random.Random(canonical_seed(self.seed, cycle, layer)).shuffle(order)
+        start = visit * self.candidates_per_step
+        candidates = order[start:start + self.candidates_per_step]
+        if len(candidates) != self.candidates_per_step or len(set(candidates)) != len(candidates):
+            raise RuntimeError("coverage scheduler emitted an invalid candidate set")
+        return layer, candidates
+
+
+class PositiveReplayBuffer:
+    """Bounded, serializable positive-benefit replay with deterministic sampling."""
+
+    def __init__(self, maximum: int = 4096):
+        if maximum <= 0:
+            raise ValueError("replay maximum must be positive")
+        self.maximum = int(maximum)
+        self.rows: list[dict[str, Any]] = []
+
+    def add(self, rows: Iterable[dict[str, Any]]) -> None:
+        for row in rows:
+            required = {"rowId", "lane", "layer", "expert", "token", "benefitNats"}
+            if set(row) < required:
+                raise ValueError(f"replay row is missing fields: {sorted(required - set(row))}")
+            if float(row["benefitNats"]) <= 0:
+                continue
+            self.rows.append(dict(row))
+        if len(self.rows) > self.maximum:
+            del self.rows[:len(self.rows) - self.maximum]
+
+    def sample(self, seed: int, count: int = 1) -> list[dict[str, Any]]:
+        if count <= 0 or not self.rows:
+            return []
+        rng = random.Random(canonical_seed(seed, len(self.rows), count))
+        indices = list(range(len(self.rows)))
+        rng.shuffle(indices)
+        return [dict(self.rows[index]) for index in indices[:min(count, len(indices))]]
+
+    def state_dict(self) -> dict[str, Any]:
+        return {"maximum": self.maximum, "rows": self.rows}
+
+    @classmethod
+    def from_state_dict(cls, state: dict[str, Any]) -> "PositiveReplayBuffer":
+        buffer = cls(int(state["maximum"]))
+        buffer.rows = [dict(row) for row in state.get("rows", [])][-buffer.maximum:]
+        return buffer

training/run_fable_router_optimizer_smoke.py

@@ -195,8 +195,31 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
         if not torch.isfinite(total):
             raise RuntimeError("optimizer smoke produced a non-finite objective")
         total.backward()
+        layer_gradients = []
+        for layer, block in enumerate(blocks):
+            gate_grad = block.router.gate.weight.grad
+            scale_grad = block.expert_scale.grad
+            layer_gradients.append({
+                "layer": layer,
+                "gateGradientPresent": gate_grad is not None,
+                "gateGradientL1": float(gate_grad.float().abs().sum()) if gate_grad is not None else 0.0,
+                "gateGradientMaxAbs": float(gate_grad.float().abs().max()) if gate_grad is not None else 0.0,
+                "gateGradientNonzero": int(torch.count_nonzero(gate_grad)) if gate_grad is not None else 0,
+                "scaleGradientPresent": scale_grad is not None,
+                "scaleGradientAbs": float(scale_grad.float().abs()) if scale_grad is not None else 0.0,
+            })
+        step_before = [block.router.gate.weight.detach().cpu().clone() for block in blocks]
         grad_norm = float(torch.nn.utils.clip_grad_norm_(parameters, float(optimizer_contract["gradientClipNorm"])))
         optimizer.step()
+        layer_updates = []
+        for layer, (block, previous) in enumerate(zip(blocks, step_before, strict=True)):
+            delta = (block.router.gate.weight.detach().cpu() - previous).abs()
+            layer_updates.append({
+                "layer": layer,
+                "gateUpdateL1": float(delta.sum()),
+                "gateUpdateMaxAbs": float(delta.max()),
+                "gateUpdateNonzero": int(torch.count_nonzero(delta)),
+            })
         metrics.append({
             "step": step,
             "lane": row["lane"],
@@ -207,22 +230,32 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
             "totalLoss": float(total.detach()),
             "gradientNorm": grad_norm,
             "discovery": discovery,
+            "layerGradients": layer_gradients,
+            "layerUpdates": layer_updates,
         })
+        result["steps"] = metrics
         del batch, host_logits, routed
 
     if not positive_and_off:
         raise RuntimeError("counterfactual optimizer smoke did not produce both expert and host-only targets")
     after_state = router_state_dict(model)
     changed_layers = []
+    update_diagnostics = []
     for layer in range(30):
-        key = f"model.layers.{layer}.expert_block.router.gate.weight"
-        if not torch.equal(before_state[key], after_state[key]):
+        gate_key = f"model.layers.{layer}.expert_block.router.gate.weight"
+        scale_key = f"model.layers.{layer}.expert_block.expert_scale"
+        gate_delta = (after_state[gate_key] - before_state[gate_key]).abs()
+        scale_delta = (after_state[scale_key] - before_state[scale_key]).abs()
+        if torch.count_nonzero(gate_delta):
             changed_layers.append(layer)
-    if changed_layers != list(range(30)):
-        raise RuntimeError(f"not every router gate updated: {changed_layers}")
+        update_diagnostics.append({
+            "layer": layer,
+            "gateUpdateL1": float(gate_delta.sum()),
+            "gateUpdateMaxAbs": float(gate_delta.max()),
+            "gateUpdateNonzero": int(torch.count_nonzero(gate_delta)),
+            "scaleUpdateAbs": float(scale_delta),
+        })
     maximum_scale = max(float(F.softplus(block.expert_scale).detach()) for block in blocks)
-    if maximum_scale > 0.0250001:
-        raise RuntimeError(f"Stage A expert scale exceeded 0.025: {maximum_scale}")
 
     output = Path(result["output"])
     checkpoint = output / "router-checkpoint.safetensors"
@@ -230,7 +263,11 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     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)
     result["steps"] = metrics
-    result["updateGate"] = {"changedRouterLayers": changed_layers, "maximumExpertScale": maximum_scale}
+    result["updateGate"] = {
+        "changedRouterLayers": changed_layers,
+        "maximumExpertScale": maximum_scale,
+        "layerDiagnostics": update_diagnostics,
+    }
     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["runtime"] = {
@@ -239,6 +276,10 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
         "peakReservedVramMiB": torch.cuda.max_memory_reserved(device) / 2**20,
         "computeDtype": str(dtype),
     }
+    if changed_layers != list(range(30)):
+        raise RuntimeError(f"not every router gate updated: {changed_layers}")
+    if maximum_scale > 0.0250001:
+        raise RuntimeError(f"Stage A expert scale exceeded 0.025: {maximum_scale}")
     result["gates"] = {gate: True for gate in optimizer_contract["requiredGates"]}
 
 

training/run_fable_router_stage_a_chunk.py

@@ -0,0 +1,500 @@
+#!/usr/bin/env python3
+"""Run one resumable, non-routing Stage-A chunk for a frozen Fable donor bank."""
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+import json
+import os
+import platform
+import random
+import sys
+import time
+import traceback
+from datetime import datetime, timezone
+from pathlib import Path
+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
+
+HERE = Path(__file__).resolve().parent
+if str(HERE) not in sys.path:
+    sys.path.insert(0, str(HERE))
+
+from fable_router_common import iter_jsonl, read_json, selected_expert_ids, sha256, validate_bank_header, validate_curriculum_row, verify_file
+from fable_router_hybrid import (
+    FrozenExpertRouterBlock,
+    assert_trainable_isolation,
+    attach_router_block,
+    benefit_targets,
+    benefit_weighted_router_loss,
+    freeze_except_routers,
+    load_router_state_dict,
+    router_state_dict,
+)
+from fable_router_training_schedule import (
+    ExpertCoverageSchedule,
+    PositiveReplayBuffer,
+    benefit_margin,
+    canonical_seed,
+    frozen_lane_schedule,
+    linear_anneal,
+    route_cost_multiplier,
+    stage_position,
+)
+from run_fable_router_full_bank_fit import download, verify_authorization
+from run_fable_router_structural_smoke import compute_dtype, gpu_facts, render_and_tokenize, token_nll
+
+
+SEED = 20260810
+MAXIMUM_TOKENS = 2048
+MAXIMUM_CHUNK_STEPS = 25
+LEARNING_RATE = 2e-4
+GRADIENT_CLIP = 1.0
+REPLAY_MAXIMUM = 4096
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def set_blocks(blocks: list[FrozenExpertRouterBlock], enabled: bool) -> None:
+    for block in blocks:
+        block.enabled = enabled
+
+
+def assistant_supervision(tokenizer: Any, messages: list[dict[str, Any]]) -> tuple[list[int], list[int]]:
+    """Create assistant-only labels while requiring a prefix-stable chat template."""
+    input_ids: list[int] = []
+    labels: list[int] = []
+    for index, message in enumerate(messages):
+        rendered = render_and_tokenize(tokenizer, messages[:index + 1])
+        if rendered[:len(input_ids)] != input_ids:
+            raise RuntimeError("chat template is not prefix-stable; assistant masking would be ambiguous")
+        added = rendered[len(input_ids):]
+        input_ids.extend(added)
+        supervised = str(message.get("role")) == "assistant"
+        labels.extend(added if supervised else [-100] * len(added))
+    if len(input_ids) != len(labels) or not any(label != -100 for label in labels):
+        raise RuntimeError("curriculum row produced no unambiguous assistant supervision")
+    return input_ids, labels
+
+
+def load_row_pools(path: Path, tokenizer: Any) -> dict[str, list[dict[str, Any]]]:
+    pools = {lane: [] for lane in ("host_preservation", "verified_expert", "interaction_pattern")}
+    for row in iter_jsonl(path):
+        validate_curriculum_row(row, "train")
+        lane = str(row["lane"])
+        input_ids, labels = assistant_supervision(tokenizer, row["messages"])
+        if len(input_ids) > MAXIMUM_TOKENS:
+            raise RuntimeError(f"frozen curriculum row exceeds {MAXIMUM_TOKENS} tokens after template: {row['id']}")
+        pools[lane].append({"id": str(row["id"]), "lane": lane, "inputIds": input_ids, "labels": labels})
+    for lane, rows in pools.items():
+        if not rows:
+            raise RuntimeError(f"frozen curriculum has no rows for lane {lane}")
+        random.Random(canonical_seed(SEED, "rows", lane)).shuffle(rows)
+    return pools
+
+
+def scheduled_rows(pools: dict[str, list[dict[str, Any]]], schedule: list[str], start: int, end: int) -> list[dict[str, Any]]:
+    offsets = Counter(schedule[:start])
+    selected = []
+    for lane in schedule[start:end]:
+        rows = pools[lane]
+        selected.append(rows[offsets[lane] % len(rows)])
+        offsets[lane] += 1
+    return selected
+
+
+def batch_row(row: dict[str, Any], device: torch.device) -> dict[str, torch.Tensor]:
+    return {
+        "input_ids": torch.tensor([row["inputIds"]], dtype=torch.long, device=device),
+        "attention_mask": torch.ones((1, len(row["inputIds"])), dtype=torch.long, device=device),
+        "labels": torch.tensor([row["labels"]], dtype=torch.long, device=device),
+    }
+
+
+def valid_shift_mask(labels: torch.Tensor) -> torch.Tensor:
+    return labels[:, 1:] != -100
+
+
+def host_baseline(model: torch.nn.Module, blocks: list[FrozenExpertRouterBlock], batch: dict[str, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
+    set_blocks(blocks, False)
+    model.eval()
+    with torch.inference_mode():
+        logits = model(input_ids=batch["input_ids"], attention_mask=batch["attention_mask"], use_cache=False).logits
+        valid = valid_shift_mask(batch["labels"])
+        host_valid = logits[:, :-1, :][valid].detach().to(device="cpu", dtype=torch.float16)
+        host_nll = token_nll(logits, batch["labels"])[valid].detach().cpu()
+    del logits
+    return host_valid, host_nll
+
+
+def chunked_kl(routed_valid: torch.Tensor, host_valid_cpu: torch.Tensor, chunk_tokens: int = 32) -> torch.Tensor:
+    if routed_valid.shape != host_valid_cpu.shape:
+        raise RuntimeError(f"host/routed KL shapes differ: {routed_valid.shape} {host_valid_cpu.shape}")
+    total = torch.zeros((), dtype=torch.float32, device=routed_valid.device)
+    for start in range(0, routed_valid.shape[0], chunk_tokens):
+        routed = routed_valid[start:start + chunk_tokens].float()
+        host = host_valid_cpu[start:start + chunk_tokens].to(routed_valid.device).float()
+        total = total + F.kl_div(F.log_softmax(routed, dim=-1), F.softmax(host, dim=-1), reduction="sum")
+    return total / max(1, routed_valid.shape[0])
+
+
+def counterfactual_targets(
+    model: torch.nn.Module,
+    blocks: list[FrozenExpertRouterBlock],
+    batch: dict[str, torch.Tensor],
+    host_nll: torch.Tensor,
+    layer: int,
+    candidates: list[int],
+    scale: float,
+    margin: float,
+) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any], list[dict[str, Any]]]:
+    candidate_losses = []
+    valid = valid_shift_mask(batch["labels"])
+    set_blocks(blocks, False)
+    blocks[layer].enabled = True
+    for candidate in candidates:
+        with blocks[layer].forced_route(candidate, scale), torch.inference_mode():
+            logits = model(input_ids=batch["input_ids"], attention_mask=batch["attention_mask"], use_cache=False).logits
+            candidate_losses.append(token_nll(logits, batch["labels"])[valid].detach().cpu())
+        del logits
+    matrix = torch.stack(candidate_losses, dim=-1)
+    column_targets = benefit_targets(host_nll, matrix, margin=margin)
+    mapped = torch.full_like(column_targets, blocks[layer].off_class_index)
+    for column, local_expert in enumerate(candidates):
+        mapped[column_targets == column] = local_expert
+    positive = mapped != blocks[layer].off_class_index
+    best_nll, _ = matrix.min(dim=-1)
+    benefits = (host_nll - best_nll).clamp_min(0)
+    replay = [
+        {
+            "rowId": "__set_by_caller__",
+            "lane": "__set_by_caller__",
+            "layer": layer,
+            "expert": int(mapped[token]),
+            "token": token,
+            "benefitNats": float(benefits[token]),
+        }
+        for token in positive.nonzero(as_tuple=False).flatten().tolist()
+    ]
+    discovery = {
+        "layer": layer,
+        "candidates": candidates,
+        "scale": scale,
+        "eligibleTokens": int(mapped.numel()),
+        "positiveBenefitTokens": int(positive.sum()),
+        "hostOnlyTargets": int((~positive).sum()),
+        "meanPositiveBenefitNats": float(benefits[positive].mean()) if bool(positive.any()) else 0.0,
+    }
+    return mapped, matrix, discovery, replay
+
+
+def load_resume(args: argparse.Namespace) -> tuple[dict[str, Any] | None, PositiveReplayBuffer, int]:
+    if not args.resume_dir:
+        if args.start_step != 0:
+            raise RuntimeError("a nonzero start step requires a resume directory")
+        return None, PositiveReplayBuffer(REPLAY_MAXIMUM), 0
+    directory = args.resume_dir.resolve()
+    result = read_json(directory / "result.json")
+    state = read_json(directory / "trainer-state.json")
+    if result.get("passed") is not True or result.get("status") != "stage_a_chunk_passed_nonrouting":
+        raise RuntimeError("resume result is not a passing Stage-A chunk")
+    if str(result.get("bank")) != args.bank or int(state.get("completedSteps", -1)) != args.start_step:
+        raise RuntimeError("resume bank/step identity mismatch")
+    return state, PositiveReplayBuffer.from_state_dict(state["positiveReplay"]), int(state["eligibleSteps"])
+
+
+def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
+    campaign, config, manifest = verify_authorization(args.campaign.resolve(), result)
+    curriculum_path = args.campaign.resolve().parents[2] / campaign["frozenCurriculum"]["path"]
+    curriculum = read_json(curriculum_path)
+    if args.bank not in campaign["selectedBanks"]["ids"]:
+        raise RuntimeError("bank is outside the frozen authorized set")
+    if args.steps <= 0 or args.steps > MAXIMUM_CHUNK_STEPS:
+        raise RuntimeError(f"Stage-A chunks must contain 1..{MAXIMUM_CHUNK_STEPS} steps")
+    end_step = args.start_step + args.steps
+    if args.start_step < 0 or end_step > 200:
+        raise RuntimeError("this fail-closed runner is restricted to Stage A steps 0..199")
+    for step in range(args.start_step, end_step):
+        if stage_position(curriculum, step).name != "A-host-anchor":
+            raise RuntimeError("requested chunk crosses outside Stage A")
+
+    proof = read_json(args.optimizer_proof.resolve())
+    if (
+        proof.get("schema") != "AutonomaFableRouterOptimizerSmoke.v1"
+        or proof.get("passed") is not True
+        or proof.get("status") != "optimizer_smoke_passed_nonrouting"
+        or proof.get("bank") != args.bank
+        or proof.get("nonRouting") is not True
+        or proof.get("productionRoutingAuthorized") is not False
+    ):
+        raise RuntimeError("bank-specific optimizer admission prerequisite is not a pass")
+    resume_state, replay, eligible_step = load_resume(args)
+    result["optimizerProof"] = {"path": str(args.optimizer_proof.resolve()), "sha256": sha256(args.optimizer_proof.resolve())}
+    result["bank"] = args.bank
+    result["range"] = {"start": args.start_step, "end": end_step, "steps": args.steps}
+    result["gpu"] = gpu_facts(14.0)
+    if result["gpu"]["name"] not in campaign["computePolicy"]["allowedAccelerators"]:
+        raise RuntimeError("Stage-A accelerator is outside the zero-cost allowlist")
+
+    banks = {row["id"]: row for row in manifest["banks"]}
+    definition = banks[args.bank]
+    token = os.environ.get("HF_TOKEN")
+    bank_cfg = config["banks"]
+    artifact = bank_cfg["artifacts"][args.bank]
+    bank_path = download(bank_cfg["repo"], bank_cfg["revision"], artifact["path"], "model", token)
+    result["bankArtifact"] = verify_file(bank_path, int(artifact["bytes"]), artifact["sha256"])
+    result["bankValidation"] = validate_bank_header(bank_path, definition).as_dict()
+    warm = bank_cfg["routerWarmstart"]
+    warm_path = download(bank_cfg["repo"], bank_cfg["revision"], warm["path"], "model", token)
+    verify_file(warm_path, int(warm["bytes"]), warm["sha256"])
+    train_cfg = config["curriculum"]["sftTrain"]
+    train_path = args.curriculum_path.resolve()
+    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)
+    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)
+    result["rows"] = [{"step": args.start_step + i, "id": row["id"], "lane": row["lane"], "tokens": len(row["inputIds"])} for i, row in enumerate(rows)]
+
+    device = torch.device("cuda:0")
+    dtype = compute_dtype(result["gpu"])
+    torch.cuda.reset_peak_memory_stats(device)
+    started = time.perf_counter()
+    model = AutoModelForCausalLM.from_pretrained(
+        host["repo"], revision=host["revision"], token=token, trust_remote_code=True,
+        torch_dtype=dtype, low_cpu_mem_usage=True, attn_implementation="sdpa",
+    ).to(device)
+    model.config.use_cache = False
+    model.gradient_checkpointing_enable(gradient_checkpointing_kwargs={"use_reentrant": False})
+    model.enable_input_require_grads()
+    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)
+        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_router_warmstart(warm_state[f"layers.{layer}.router.gate.weight"])
+        block.checkpoint_enabled = True
+        blocks.append(block)
+    counts = freeze_except_routers(model)
+    names = assert_trainable_isolation(model)
+    if len(names) != 60:
+        raise RuntimeError(f"Stage-A chunk found {len(names)} trainable tensors instead of 60")
+    if resume_state is not None:
+        load_router_state_dict(model, load_file(str(args.resume_dir.resolve() / "router-checkpoint.safetensors"), device="cpu"))
+    result["trainableIsolation"] = {"counts": counts, "names": names}
+    before = router_state_dict(model)
+    parameters = [parameter for parameter in model.parameters() if parameter.requires_grad]
+    optimizer = torch.optim.AdamW(parameters, lr=LEARNING_RATE, weight_decay=0.0)
+    if resume_state is not None:
+        payload = torch.load(args.resume_dir.resolve() / "optimizer.pt", map_location="cpu", weights_only=True)
+        if int(payload.get("completedSteps", -1)) != args.start_step or payload.get("bank") != args.bank:
+            raise RuntimeError("optimizer resume identity mismatch")
+        optimizer.load_state_dict(payload["optimizer"])
+
+    coverage = ExpertCoverageSchedule(seed=SEED)
+    metrics = []
+    oracle_scales = [float(value) for value in curriculum["routingObjective"]["exploration"]["oracleProbeScales"]]
+    for offset, row in enumerate(rows):
+        global_step = args.start_step + offset
+        batch = batch_row(row, device)
+        host_valid_cpu, host_nll = host_baseline(model, blocks, batch)
+        valid = valid_shift_mask(batch["labels"])[0]
+        mapped = matrix = None
+        discovery = None
+        replay_rows: list[dict[str, Any]] = []
+        probe_layer = None
+        if row["lane"] != "host_preservation":
+            probe_layer, candidates = coverage.probe(eligible_step)
+            scale = oracle_scales[eligible_step % len(oracle_scales)]
+            mapped, matrix, discovery, replay_rows = counterfactual_targets(
+                model, blocks, batch, host_nll, probe_layer, candidates, scale, benefit_margin(global_step)
+            )
+            for replay_row in replay_rows:
+                replay_row["rowId"] = row["id"]
+                replay_row["lane"] = row["lane"]
+            replay.add(replay_rows)
+            eligible_step += 1
+
+        set_blocks(blocks, True)
+        for block in blocks:
+            block.maximum_scale = 0.025
+        model.train()
+        optimizer.zero_grad(set_to_none=True)
+        routed = model(**batch, use_cache=False)
+        routed_valid = routed.logits[:, :-1, :][valid_shift_mask(batch["labels"])]
+        kl = chunked_kl(routed_valid, host_valid_cpu)
+        ranking = off_loss = floor_loss = load_balance = torch.zeros((), device=device)
+        entropy_reward = torch.zeros((), device=device)
+        active_penalty = torch.zeros((), device=device)
+        if probe_layer is not None and mapped is not None and matrix is not None:
+            trace = blocks[probe_layer].last_trace
+            if trace is None:
+                raise RuntimeError("eligible routed forward produced no router trace")
+            logits = trace.logits[:-1][valid]
+            ranking = benefit_weighted_router_loss(logits, mapped.to(device), host_nll.to(device), matrix.to(device))
+            probabilities = torch.softmax(logits.float(), dim=-1)
+            positive = mapped.to(device) != blocks[probe_layer].off_class_index
+            if bool(positive.any()):
+                expert_probabilities = probabilities[positive, :-1]
+                expert_mass = expert_probabilities.sum(dim=-1)
+                minimum_mass = linear_anneal(0.15, 0.0, global_step, 300)
+                floor_loss = F.relu(minimum_mass - expert_mass).mean()
+                entropy = -(expert_probabilities.clamp_min(1e-9) * expert_probabilities.clamp_min(1e-9).log()).sum(dim=-1).mean()
+                entropy_reward = linear_anneal(0.01, 0.0, global_step, 300) * entropy
+                active_penalty = expert_mass.mean()
+                mean_usage = expert_probabilities.mean(dim=0)
+                load_balance = ((mean_usage - mean_usage.mean()) ** 2).mean()
+        else:
+            off_terms = []
+            for block in blocks:
+                trace = block.last_trace
+                if trace is None:
+                    raise RuntimeError("host-preservation routed forward produced no router trace")
+                logits = trace.logits[:-1][valid]
+                targets = torch.full((logits.shape[0],), block.off_class_index, dtype=torch.long, device=device)
+                off_terms.append(F.cross_entropy(logits.float(), targets))
+            off_loss = torch.stack(off_terms).mean()
+
+        lane_cfg = curriculum["lanes"][row["lane"]]
+        scale_l1 = torch.stack([F.softplus(block.expert_scale).clamp(max=0.025) for block in blocks]).mean()
+        cost_multiplier = route_cost_multiplier(global_step)
+        route_cost = cost_multiplier * (0.015 * scale_l1 + 0.005 * active_penalty)
+        total = (
+            float(lane_cfg["sftWeight"]) * routed.loss
+            + float(lane_cfg["baseFableKlWeight"]) * kl
+            + ranking + off_loss + floor_loss
+            + 0.01 * load_balance + route_cost - entropy_reward
+        )
+        if not torch.isfinite(total):
+            raise RuntimeError("Stage-A chunk produced a non-finite objective")
+        total.backward()
+        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)
+        if maximum_scale > 0.0250001:
+            raise RuntimeError(f"Stage-A expert scale exceeded 0.025: {maximum_scale}")
+        metrics.append({
+            "step": global_step,
+            "rowId": row["id"],
+            "lane": row["lane"],
+            "tokens": len(row["inputIds"]),
+            "sftLoss": float(routed.loss.detach()),
+            "klLoss": float(kl.detach()),
+            "rankingLoss": float(ranking.detach()),
+            "offLoss": float(off_loss.detach()),
+            "routeFloorLoss": float(floor_loss.detach()),
+            "loadBalanceLoss": float(load_balance.detach()),
+            "routeCost": float(route_cost.detach()),
+            "entropyReward": float(entropy_reward.detach()),
+            "totalLoss": float(total.detach()),
+            "gradientNorm": gradient_norm,
+            "maximumExpertScale": maximum_scale,
+            "discovery": discovery,
+        })
+        del batch, host_valid_cpu, host_nll, routed, routed_valid, total
+
+    after = router_state_dict(model)
+    changed_layers = [
+        layer for layer in range(30)
+        if not torch.equal(before[f"model.layers.{layer}.expert_block.router.gate.weight"], after[f"model.layers.{layer}.expert_block.router.gate.weight"])
+    ]
+    if not changed_layers:
+        raise RuntimeError("Stage-A chunk did not update any router gate")
+    output = Path(result["output"])
+    checkpoint = output / "router-checkpoint.safetensors"
+    optimizer_path = output / "optimizer.pt"
+    state_path = output / "trainer-state.json"
+    metrics_path = output / "metrics.jsonl"
+    save_file(after, str(checkpoint), metadata={"autonoma": "non-routing-stage-a", "bank": args.bank, "completedSteps": str(end_step)})
+    torch.save({"optimizer": optimizer.state_dict(), "completedSteps": end_step, "bank": args.bank}, optimizer_path)
+    state = {
+        "schema": "AutonomaFableRouterTrainerState.v1",
+        "bank": args.bank,
+        "completedSteps": end_step,
+        "eligibleSteps": eligible_step,
+        "seed": SEED,
+        "positiveReplay": replay.state_dict(),
+    }
+    state_path.write_text(json.dumps(state, indent=2) + "\n", encoding="utf-8")
+    with metrics_path.open("w", encoding="utf-8", newline="\n") as handle:
+        for metric in metrics:
+            handle.write(json.dumps(metric, separators=(",", ":")) + "\n")
+    result["metrics"] = {"path": str(metrics_path), "bytes": metrics_path.stat().st_size, "sha256": sha256(metrics_path)}
+    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["trainerState"] = {"path": str(state_path), "bytes": state_path.stat().st_size, "sha256": sha256(state_path)}
+    result["updateGate"] = {"changedRouterLayers": changed_layers, "positiveReplayRows": len(replay.rows), "eligibleSteps": eligible_step}
+    result["runtime"] = {
+        "seconds": time.perf_counter() - started,
+        "peakAllocatedVramMiB": torch.cuda.max_memory_allocated(device) / 2**20,
+        "peakReservedVramMiB": torch.cuda.max_memory_reserved(device) / 2**20,
+        "computeDtype": str(dtype),
+    }
+    result["gates"] = {
+        "authorized_frozen_four_bank_campaign": True,
+        "bank_specific_optimizer_admission": True,
+        "assistant_only_prefix_stable_supervision": True,
+        "complete_rows_without_truncation": True,
+        "host_and_experts_frozen": True,
+        "deterministic_lane_and_expert_coverage": True,
+        "counterfactual_off_class_and_positive_replay": True,
+        "stage_a_scale_cap": True,
+        "resumable_private_checkpoints": True,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner-execute", action="store_true")
+    parser.add_argument("--campaign", type=Path, required=True)
+    parser.add_argument("--bank", required=True)
+    parser.add_argument("--curriculum-path", type=Path, required=True)
+    parser.add_argument("--optimizer-proof", 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)
+    parser.add_argument("--work-dir", type=Path, default=Path("/content/autonoma-fable-training"))
+    args = parser.parse_args()
+    if not args.owner_execute:
+        raise SystemExit("refusing Stage-A execution without --owner-execute")
+    args.work_dir.mkdir(parents=True, exist_ok=True)
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    output = args.work_dir / f"fable-router-stage-a-{args.bank}-{args.start_step:04d}-{args.start_step + args.steps:04d}-{stamp}"
+    output.mkdir(parents=True, exist_ok=False)
+    result: dict[str, Any] = {
+        "schema": "AutonomaFableRouterStageAChunk.v1",
+        "status": "running_nonrouting",
+        "passed": False,
+        "nonRouting": True,
+        "trainingAuthorized": True,
+        "productionRoutingAuthorized": False,
+        "startedAt": now(),
+        "output": str(output),
+        "system": {"python": sys.version, "platform": platform.platform()},
+    }
+    try:
+        run(args, result)
+        result.update(status="stage_a_chunk_passed_nonrouting", passed=True)
+    except BaseException as exc:
+        result.update(status="stage_a_chunk_failed_nonrouting", error={"type": type(exc).__name__, "message": str(exc), "traceback": traceback.format_exc()})
+    finally:
+        result["finishedAt"] = now()
+        result_path = output / "result.json"
+        result_path.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
+        print(result_path.resolve())
+    return 0 if result.get("passed") else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())