main-training.py

"""
CascadeFormer  ·  SmilyAI 3rd Gen Assistant
Heterogeneous Mixture-of-Experts Transformer — TRITON KERNEL EDITION (v3, speed patch)

Same architecture as before, but:
  - RMSNorm -> fused triton kernel (fwd+bwd)
  - RoPE -> fused triton kernel (fwd+bwd)
  - Attention -> fused triton flash-attn w/ window support (fwd triton, bwd via flex_attention block mask)
    * v2: fixed -inf/-inf NaN edge case in softmax online-max init (NEG_INF sentinel)
    * v3: bwd swapped from dense SDPA mask -> flex_attention block_mask (skips masked blocks)
  - MoE expert dispatch -> grouped-GEMM triton kernel (no more per-expert python loop)
    * v3: dW (weight-grad) path also moved off the per-expert python loop onto a
          fused atomic-accumulate triton kernel (_moe_dw_kernel)
    * v3: forward/dW GEMMs autotuned over BLOCK_N/BLOCK_K/warps/stages — BLOCK_M is
          NOT autotuned since it's tied to the block-aligned token layout from
          moe_align_block_size; changing it there without changing block_m would
          silently misalign expert boundaries and corrupt gradients.
  - Muon -> extended to handle 3D fused expert weight tensors

HOW TO RUN (for hugging-science):
  Set these environment variables before launching:

    export HF_TOKEN=your_hf_token_here
    export HF_USERNAME=hugging-science
    export CASCADEFORMER_SESSION_ID=3
    export HF_MODEL_REPO_BASE=hugging-science/cascadeformer
    export HF_DATASET_REPO=Bc-AI/CodVa-1-Pretrain-20B

  Then: python train.py

METRICS:
  A metrics_session{N}.jsonl file is written locally and uploaded to the HF
  checkpoint repo every 15 min. Pull it any time to check training progress.
  Each line is a JSON object with kind="train"|"val"|"ckpt"|"final".

TIME BUDGET:
  MAX_TRAINING_HOURS = 53.0 (~54h32m total, leaving ~1.5h buffer for cleanup)

SESSION NOTES:
  Session 3 = fresh pretrain on Bc-AI/CodVa-1-Pretrain-20B corpus.
  To resume within session 3, uncomment the checkpoint resume block in train().
  Old session repos (1, 2) are auto-deleted after session 3 starts.

ARCHITECTURE NOTE:
  If resuming from a checkpoint saved with the OLD (non-fused) architecture,
  MoE expert weights will NOT match key names and will silently stay randomly
  initialized (load_state_dict uses strict=False). Session 3 starts clean.
"""

import os
import gc
import json
import time
import math
import random
import logging
from dataclasses import dataclass, asdict
from typing import Optional, List

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader

try:
    import triton
    import triton.language as tl
    HAS_TRITON = True
except ImportError:
    HAS_TRITON = False
    raise RuntimeError(
        "triton is required. pip install triton or use a torch build that ships it."
    )

try:
    from torch.nn.attention.flex_attention import flex_attention, create_block_mask
    HAS_FLEX_ATTN = True
except ImportError:
    HAS_FLEX_ATTN = False

from huggingface_hub import HfApi, hf_hub_download, upload_file
from huggingface_hub import login as hf_login

try:
    import bitsandbytes as bnb
    HAS_BNB = True
    print("bitsandbytes: ON")
except ImportError:
    HAS_BNB = False

try:
    from safetensors.torch import save_file as st_save
    HAS_ST = True
    print("safetensors: ON")
except ImportError:
    HAS_ST = False

try:
    from torchao.float8 import convert_to_float8_training, Float8LinearConfig
    HAS_TORCHAO = True
    print("torchao fp8: ON")
except ImportError:
    HAS_TORCHAO = False

os.environ["CUDA_DEVICE_ORDER"]      = "PCI_BUS_ID"
os.environ["TOKENIZERS_PARALLELISM"] = "false"
torch.set_float32_matmul_precision("high")
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32       = True
torch.backends.cudnn.benchmark        = True

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(message)s",
    datefmt="%H:%M:%S",
)
log = logging.getLogger("cascadeformer")

if not HAS_FLEX_ATTN:
    log.warning(
        "[attn] flex_attention not available (needs torch>=2.5) — "
        "attention backward will fail. Upgrade torch."
    )

# ══════════════════════════════════════════════════════════════════════════════
#  HUGGINGFACE HUB SETUP
# ══════════════════════════════════════════════════════════════════════════════
HF_TOKEN    = os.environ.get("HF_TOKEN", "")
HF_USERNAME = os.environ.get("HF_USERNAME", "hugging-science")

HF_DATASET_REPO = os.environ.get("HF_DATASET_REPO", "Bc-AI/CodVa-1-Pretrain-20B")

SESSION_ID          = int(os.environ.get("CASCADEFORMER_SESSION_ID", "3"))
HF_MODEL_REPO_BASE  = os.environ.get("HF_MODEL_REPO_BASE", "hugging-science/cascadeformer")
HF_MODEL_REPO       = f"{HF_MODEL_REPO_BASE}-session-{SESSION_ID:03d}"

if not HF_TOKEN:
    log.warning(
        "[hf] HF_TOKEN env var not set — uploads/downloads will fail. "
        "Set it with:  export HF_TOKEN=your_token"
    )
else:
    try:
        hf_login(token=HF_TOKEN)
        log.info(f"[hf] logged in | user={HF_USERNAME}")
    except Exception as e:
        log.warning(f"[hf] login failed: {e}")

hf_api = HfApi()

LOCAL_CACHE   = "/tmp/cascadeformer_cache"
TEMP_CKPT_DIR = "/tmp/cascadeformer_ckpts"
os.makedirs(LOCAL_CACHE,   exist_ok=True)
os.makedirs(TEMP_CKPT_DIR, exist_ok=True)

log.info(f"[session] ID={SESSION_ID}  ckpt_repo={HF_MODEL_REPO}  data={HF_DATASET_REPO}")


def ensure_session_repo_exists():
    try:
        hf_api.repo_info(repo_id=HF_MODEL_REPO, repo_type="model", token=HF_TOKEN)
        log.info(f"[hf] repo {HF_MODEL_REPO} already exists")
    except Exception:
        try:
            hf_api.create_repo(
                repo_id=HF_MODEL_REPO, repo_type="model",
                private=False, token=HF_TOKEN,
            )
            log.info(f"[hf] created repo {HF_MODEL_REPO}")
        except Exception as e:
            log.error(f"[hf] could not create repo: {e}")


def delete_old_session_repos(keep_last_n: int = 2):
    if SESSION_ID <= keep_last_n:
        return
    for old in range(1, SESSION_ID - keep_last_n + 1):
        repo = f"{HF_MODEL_REPO_BASE}-session-{old:03d}"
        try:
            hf_api.delete_repo(repo_id=repo, repo_type="model", token=HF_TOKEN)
            log.info(f"[hf] deleted old session repo: {repo}")
        except Exception as e:
            log.debug(f"[hf] could not delete {repo}: {e}")


def download_dataset_file(filename: str, cache_dir: str = LOCAL_CACHE) -> str:
    path = hf_hub_download(
        repo_id=HF_DATASET_REPO, filename=filename,
        repo_type="dataset", cache_dir=cache_dir, token=HF_TOKEN,
    )
    log.info(f"[hf] downloaded dataset file: {filename}")
    return path


def upload_to_hf(local_path: str, remote_filename: str) -> bool:
    """Upload any local file to the session checkpoint repo."""
    try:
        upload_file(
            path_or_fileobj=local_path,
            path_in_repo=remote_filename,
            repo_id=HF_MODEL_REPO,
            repo_type="model",
            token=HF_TOKEN,
        )
        log.info(f"[hf] uploaded {remote_filename}")
        return True
    except Exception as e:
        log.error(f"[hf] upload failed ({remote_filename}): {e}")
        return False


def list_hf_checkpoints() -> List[str]:
    try:
        files = hf_api.list_repo_files(
            repo_id=HF_MODEL_REPO, repo_type="model", token=HF_TOKEN
        )
        ckpts = [f for f in files if f.endswith(".model.pt")]
        return sorted(
            ckpts,
            key=lambda x: int(x.split("_s")[-1].split(".")[0]) if "_s" in x else 0,
        )
    except Exception as e:
        log.warning(f"[hf] list_repo_files failed: {e}")
        return []


def find_latest_checkpoint() -> Optional[str]:
    ckpts = list_hf_checkpoints()
    if not ckpts:
        return None
    latest = ckpts[-1]
    log.info(f"[hf] latest checkpoint: {latest}")
    return latest.replace(".model.pt", "")


# ══════════════════════════════════════════════════════════════════════════════
#  TIME BUDGET
# ══════════════════════════════════════════════════════════════════════════════
#  TIME BUDGET
# ══════════════════════════════════════════════════════════════════════════════
MAX_TRAINING_HOURS = 53.0
TRAINING_START = time.time()

def elapsed_h()   -> float: return (time.time() - TRAINING_START) / 3600
def remaining_h() -> float: return MAX_TRAINING_HOURS - elapsed_h()
def should_stop() -> bool:
    if elapsed_h() >= MAX_TRAINING_HOURS:
        log.info(f"[time] {MAX_TRAINING_HOURS}h budget reached — stopping")
        return True
    return False

def vram_used_gb()  -> float: return torch.cuda.memory_allocated() / 1024**3
def vram_total_gb() -> float: return torch.cuda.get_device_properties(0).total_memory / 1024**3
def vram_str()      -> str:   return f"{vram_used_gb():.1f}/{vram_total_gb():.0f}GB"


# ══════════════════════════════════════════════════════════════════════════════
#  METRICS LOGGER
# ══════════════════════════════════════════════════════════════════════════════
class MetricsLogger:
    """
    Streams one JSON object per line to a local .jsonl file, then uploads
    to the HF checkpoint repo every 15 min (and always on checkpoint saves).

    Each line fields:
      t, elapsed_h, session, step, epoch, kind
      kind=train  : loss, avg50, ppl, aux_loss, muon_lr, adamw_lr,
                    tok_per_sec, sec_per_step, vram_used_gb, vram_tot_gb,
                    moe_dead, moe_slots
      kind=val    : val_loss, val_ppl, is_best
      kind=ckpt   : ok (bool)
      kind=final  : train_loss, val_loss, val_ppl, best_val
    """

    def __init__(self):
        self.local_path  = os.path.join(TEMP_CKPT_DIR, f"metrics_session{SESSION_ID:03d}.jsonl")
        self.remote_name = f"metrics_session{SESSION_ID:03d}.jsonl"
        self._f          = open(self.local_path, "a", buffering=1)  # line-buffered
        log.info(f"[metrics] writing to {self.local_path}")

    def _write(self, record: dict):
        record.setdefault("t",         time.time())
        record.setdefault("elapsed_h", round(elapsed_h(), 4))
        record.setdefault("session",   SESSION_ID)
        self._f.write(json.dumps(record) + "\n")

    def log_train(self, *, step, epoch, loss, avg50, ppl, aux_loss,
                  muon_lr, adamw_lr, tok_per_sec, sec_per_step,
                  moe_dead, moe_slots):
        self._write(dict(
            kind         = "train",
            step         = step,
            epoch        = epoch,
            loss         = round(loss,         6),
            avg50        = round(avg50,        6),
            ppl          = round(ppl,          4),
            aux_loss     = round(aux_loss,     6),
            muon_lr      = muon_lr,
            adamw_lr     = adamw_lr,
            tok_per_sec  = round(tok_per_sec,  1),
            sec_per_step = round(sec_per_step, 3),
            vram_used_gb = round(vram_used_gb(),  2),
            vram_tot_gb  = round(vram_total_gb(), 1),
            moe_dead     = moe_dead,
            moe_slots    = moe_slots,
        ))

    def log_val(self, *, step, epoch, val_loss, val_ppl, is_best):
        self._write(dict(
            kind     = "val",
            step     = step,
            epoch    = epoch,
            val_loss = round(val_loss, 6),
            val_ppl  = round(val_ppl,  4),
            is_best  = is_best,
        ))

    def log_ckpt(self, *, step, epoch, ok):
        self._write(dict(kind="ckpt", step=step, epoch=epoch, ok=ok))

    def log_final(self, *, step, epoch, train_loss, val_loss, val_ppl, best_val):
        self._write(dict(
            kind       = "final",
            step       = step,
            epoch      = epoch,
            train_loss = round(train_loss, 6),
            val_loss   = round(val_loss,   6),
            val_ppl    = round(val_ppl,    4),
            best_val   = round(best_val,   6),
        ))

    def flush_to_hf(self) -> bool:
        self._f.flush()
        try:
            ok = upload_to_hf(self.local_path, self.remote_name)
            return ok
        except Exception as e:
            log.warning(f"[metrics] HF flush failed: {e}")
            return False

    def close(self):
        self.flush_to_hf()
        self._f.close()


# ══════════════════════════════════════════════════════════════════════════════
#  CONFIG
# ══════════════════════════════════════════════════════════════════════════════
@dataclass
class CascadeConfig:
    vocab_size: int   = 50304
    d_model:    int   = 896        # down from 1024, divisible by heads
    n_heads:    int   = 14         # 896/14 = 64 head_dim
    n_kv_heads: int   = 2          # aggressive GQA to save params
    n_layers:   int   = 20         # down from 24
    max_len:    int   = 2048

    # ── MoE tiers — biggest reduction lever ──────────────────────────────
    n_nano_experts:  int = 16      # down from 32
    n_midi_experts:  int = 24      # down from 48
    n_macro_experts: int = 8       # down from 16
    nano_hidden:     int = 224     # down from 256
    midi_hidden:     int = 448     # down from 512
    macro_hidden:    int = 1280    # down from 1536

    nano_top_k:  int = 2
    midi_top_k:  int = 2
    macro_top_k: int = 1

    nano_cost_weight:  float = 0.25
    midi_cost_weight:  float = 1.00
    macro_cost_weight: float = 3.00
    balance_coeff:     float = 0.01
    zloss_coeff:       float = 0.001

    router_noise_steps: int   = 5000
    router_noise_std:   float = 0.1
    macro_warmup_steps: int   = 5000

    local_window_size: int   = 512
    rope_theta:        float = 500000.0

    # ── optimizer — slightly more aggressive given smaller model ──────────
    muon_lr:      float = 0.014    # slightly higher for smaller model
    muon_min_lr:  float = 0.0014
    muon_momentum:float = 0.95
    adamw_lr:     float = 0.0005
    adamw_min_lr: float = 0.00005
    weight_decay: float = 0.1
    beta1:        float = 0.9
    beta2:        float = 0.95
    grad_clip:    float = 1.0
    warmup_steps: int   = 2000
    total_steps:  int   = 850000   # more steps since model is smaller/faster

    micro_batch: int = 4           # overridden by batch search anyway
    grad_accum:  int = 8
    log_every:   int = 10
    eval_every:  int = 500
    ckpt_every:  int = 2000
    seed:        int = 42

    use_fp8: str = "off"

    @property
    def dtype(self):
        return torch.bfloat16

    @property
    def head_dim(self):
        return self.d_model // self.n_heads

    @property
    def total_experts_per_layer(self):
        return self.n_nano_experts + self.n_midi_experts + self.n_macro_experts

    def effective_batch_tokens(self, micro: int) -> int:
        return micro * self.grad_accum * self.max_len


# ══════════════════════════════════════════════════════════════════════════════
#  DATA
# ══════════════════════════════════════════════════════════════════════════════
class TokenDataset(Dataset):
    """
    Expects a .npy file with shape (n_chunks, seq_len) and dtype int32/int64.
    Rows are shuffled per-epoch with a fixed seed so resuming is deterministic.
    """

    def __init__(self, hf_filename: str, epoch: int = 0):
        local_path = download_dataset_file(hf_filename)
        self.data    = np.load(local_path, mmap_mode="r")
        self.n       = len(self.data)
        self.seq_len = self.data.shape[1]
        self.indices = np.random.default_rng(42 + epoch).permutation(self.n)
        log.info(
            f"[data] {hf_filename} | epoch={epoch} | "
            f"{self.n:,} chunks | {self.n * self.seq_len / 1e9:.3f}B tokens | "
            f"seq_len={self.seq_len}"
        )

    def __len__(self):
        return self.n

    def __getitem__(self, i):
        return torch.from_numpy(self.data[self.indices[i]].astype(np.int64).copy())


class FixedLoader:
    """Infinite iterator over epochs; rebuilds DataLoader on each epoch boundary."""

    def __init__(self, hf_filename: str, batch_size: int, num_workers: int = 4):
        self.hf_filename = hf_filename
        self.batch_size  = batch_size
        self.num_workers = num_workers
        self.epoch       = 0
        self.loader      = None
        self._build()

    def _build(self):
        if self.loader is not None:
            try:
                del self.loader
            except Exception:
                pass
            gc.collect()
        ds = TokenDataset(self.hf_filename, self.epoch)
        self.loader = DataLoader(
            ds,
            batch_size=self.batch_size,
            shuffle=False,
            num_workers=self.num_workers,
            pin_memory=True,
            drop_last=True,
            prefetch_factor=4 if self.num_workers > 0 else None,
            persistent_workers=self.num_workers > 0,
        )
        self.it = iter(self.loader)
        log.info(
            f"[data] loader rebuilt | epoch={self.epoch + 1} "
            f"bs={self.batch_size} steps/epoch≈{len(self.loader)}"
        )

    def __next__(self):
        try:
            return next(self.it), self.epoch
        except StopIteration:
            self.epoch += 1
            self._build()
            return next(self.it), self.epoch


# ══════════════════════════════════════════════════════════════════════════════
#  TRITON KERNELS
# ══════════════════════════════════════════════════════════════════════════════

# ── 1. Fused RMSNorm ─────────────────────────────────────────────────────────
@triton.jit
def _rmsnorm_fwd_kernel(X, W, Y, Rstd, N, eps, BLOCK_N: tl.constexpr):
    row  = tl.program_id(0)
    cols = tl.arange(0, BLOCK_N)
    mask = cols < N
    x    = tl.load(X + row * N + cols, mask=mask, other=0.0).to(tl.float32)
    var  = tl.sum(x * x, axis=0) / N
    rstd = 1.0 / tl.sqrt(var + eps)
    tl.store(Rstd + row, rstd)
    w = tl.load(W + cols, mask=mask, other=0.0).to(tl.float32)
    tl.store(Y + row * N + cols, (x * rstd * w).to(tl.bfloat16), mask=mask)


@triton.jit
def _rmsnorm_bwd_kernel(DY, X, W, Rstd, DX, DW, N, BLOCK_N: tl.constexpr):
    row  = tl.program_id(0)
    cols = tl.arange(0, BLOCK_N)
    mask = cols < N
    dy   = tl.load(DY + row * N + cols, mask=mask, other=0.0).to(tl.float32)
    x    = tl.load(X  + row * N + cols, mask=mask, other=0.0).to(tl.float32)
    w    = tl.load(W  + cols,           mask=mask, other=0.0).to(tl.float32)
    rstd = tl.load(Rstd + row)
    xhat = x * rstd
    wdy  = w * dy
    dx   = (wdy - xhat * (tl.sum(xhat * wdy, axis=0) / N)) * rstd
    tl.store(DX + row * N + cols, dx.to(tl.bfloat16), mask=mask)
    tl.atomic_add(DW + cols, dy * xhat, mask=mask)


class _RMSNormFn(torch.autograd.Function):
    @staticmethod
    def forward(ctx, x, weight, eps):
        orig_shape = x.shape
        N  = orig_shape[-1]
        x2 = x.reshape(-1, N).contiguous()
        M  = x2.shape[0]
        y    = torch.empty_like(x2, dtype=torch.bfloat16)
        rstd = torch.empty(M, dtype=torch.float32, device=x.device)
        BN   = triton.next_power_of_2(N)
        _rmsnorm_fwd_kernel[(M,)](x2, weight, y, rstd, N, eps, BLOCK_N=BN)
        ctx.save_for_backward(x2, weight, rstd)
        ctx.BN         = BN
        ctx.orig_shape = orig_shape
        return y.reshape(orig_shape)

    @staticmethod
    def backward(ctx, dy):
        x2, weight, rstd = ctx.saved_tensors
        N   = x2.shape[1]
        M   = x2.shape[0]
        dy2 = dy.reshape(-1, N).contiguous()
        dx  = torch.empty_like(x2, dtype=torch.bfloat16)
        dw  = torch.zeros(N, dtype=torch.float32, device=x2.device)
        _rmsnorm_bwd_kernel[(M,)](dy2, x2, weight, rstd, dx, dw, N, BLOCK_N=ctx.BN)
        return dx.reshape(ctx.orig_shape), dw.to(weight.dtype), None


class RMSNorm(nn.Module):
    def __init__(self, dim: int, eps: float = 1e-6):
        super().__init__()
        self.eps   = eps
        self.scale = nn.Parameter(torch.ones(dim))

    def forward(self, x):
        return _RMSNormFn.apply(x, self.scale, self.eps)


# ── 2. Fused RoPE ────────────────────────────────────────────────────────────
def precompute_freqs_cis(head_dim: int, max_len: int,
                         theta: float = 500000.0, device=None):
    freqs = 1.0 / (
        theta ** (torch.arange(0, head_dim, 2, dtype=torch.float32, device=device) / head_dim)
    )
    t     = torch.arange(max_len, dtype=torch.float32, device=device)
    freqs = torch.outer(t, freqs)
    return torch.cos(freqs), torch.sin(freqs)   # (max_len, head_dim//2) each


@triton.jit
def _rope_kernel(X, COS, SIN, OUT, L, H, HD, BLOCK_HALF: tl.constexpr):
    pid  = tl.program_id(0)   # flat index over B*L*H
    l    = (pid // H) % L
    half = HD // 2
    offs = tl.arange(0, BLOCK_HALF)
    mask = offs < half
    base = pid * HD
    x1   = tl.load(X + base + offs,        mask=mask, other=0.0).to(tl.float32)
    x2   = tl.load(X + base + half + offs, mask=mask, other=0.0).to(tl.float32)
    cos  = tl.load(COS + l * half + offs,  mask=mask, other=0.0).to(tl.float32)
    sin  = tl.load(SIN + l * half + offs,  mask=mask, other=0.0).to(tl.float32)
    tl.store(OUT + base + offs,        (x1 * cos - x2 * sin).to(tl.bfloat16), mask=mask)
    tl.store(OUT + base + half + offs, (x2 * cos + x1 * sin).to(tl.bfloat16), mask=mask)


def _rope_raw(x: torch.Tensor, cos_half: torch.Tensor, sin_half: torch.Tensor):
    B, L, H, HD = x.shape
    out        = torch.empty_like(x, dtype=torch.bfloat16)
    BLOCK_HALF = triton.next_power_of_2(HD // 2)
    _rope_kernel[(B * L * H,)](
        x.contiguous(), cos_half, sin_half, out, L, H, HD, BLOCK_HALF=BLOCK_HALF
    )
    return out


class _RopeFn(torch.autograd.Function):
    @staticmethod
    def forward(ctx, x, cos_half, sin_half):
        ctx.save_for_backward(cos_half, sin_half)
        return _rope_raw(x, cos_half, sin_half)

    @staticmethod
    def backward(ctx, dy):
        cos_half, sin_half = ctx.saved_tensors
        return _rope_raw(dy, cos_half, -sin_half), None, None


def apply_rope(xq, xk, cos, sin):
    L        = xq.shape[1]
    cos_half = cos[:L].contiguous()
    sin_half = sin[:L].contiguous()
    return (
        _RopeFn.apply(xq, cos_half, sin_half).to(xq.dtype),
        _RopeFn.apply(xk, cos_half, sin_half).to(xk.dtype),
    )


# ── 3. Fused windowed/causal attention ───────────────────────────────────────
@triton.jit
def _fwd_attn_kernel(
    Q, K, V, O, sm_scale,
    stride_qz, stride_qh, stride_qm, stride_qk,
    stride_kz, stride_kh, stride_kn, stride_kk,
    stride_vz, stride_vh, stride_vn, stride_vk,
    stride_oz, stride_oh, stride_om, stride_ok,
    H, N_CTX,
    WINDOW: tl.constexpr,
    BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr, BLOCK_D: tl.constexpr,
):
    start_m = tl.program_id(0)
    off_hz  = tl.program_id(1)
    off_z   = off_hz // H
    off_h   = off_hz  % H

    q_off = off_z * stride_qz + off_h * stride_qh
    k_off = off_z * stride_kz + off_h * stride_kh
    v_off = off_z * stride_vz + off_h * stride_vh
    o_off = off_z * stride_oz + off_h * stride_oh

    offs_m = start_m * BLOCK_M + tl.arange(0, BLOCK_M)
    offs_d = tl.arange(0, BLOCK_D)

    q = tl.load(
        Q + q_off + offs_m[:, None] * stride_qm + offs_d[None, :] * stride_qk,
        mask=offs_m[:, None] < N_CTX, other=0.0,
    )

    NEG_INF: tl.constexpr = -1e9     # v2 fix: finite sentinel avoids NaN in rescale
    m_i  = tl.zeros([BLOCK_M], dtype=tl.float32) + NEG_INF
    l_i  = tl.zeros([BLOCK_M], dtype=tl.float32)
    acc  = tl.zeros([BLOCK_M, BLOCK_D], dtype=tl.float32)

    lo = tl.maximum(0, ((start_m * BLOCK_M - WINDOW) // BLOCK_N) * BLOCK_N) if WINDOW > 0 else 0
    hi = (start_m + 1) * BLOCK_M

    for start_n in range(lo, hi, BLOCK_N):
        offs_n = start_n + tl.arange(0, BLOCK_N)
        k = tl.load(
            K + k_off + offs_n[:, None] * stride_kn + offs_d[None, :] * stride_kk,
            mask=offs_n[:, None] < N_CTX, other=0.0,
        )
        qk     = tl.dot(q, tl.trans(k)) * sm_scale
        m_idx  = offs_m[:, None]
        n_idx  = offs_n[None, :]
        causal = n_idx <= m_idx
        if WINDOW > 0:
            causal = causal & (n_idx > m_idx - WINDOW)
        qk    = tl.where(causal, qk, NEG_INF)
        m_ij  = tl.maximum(m_i, tl.max(qk, axis=1))
        p     = tl.exp(qk - m_ij[:, None])
        alpha = tl.exp(m_i - m_ij)
        l_i   = l_i * alpha + tl.sum(p, axis=1)
        acc   = acc * alpha[:, None]
        v = tl.load(
            V + v_off + offs_n[:, None] * stride_vn + offs_d[None, :] * stride_vk,
            mask=offs_n[:, None] < N_CTX, other=0.0,
        )
        acc  += tl.dot(p.to(v.dtype), v)
        m_i   = m_ij

    acc = acc / tl.maximum(l_i[:, None], 1e-9)
    tl.store(
        O + o_off + offs_m[:, None] * stride_om + offs_d[None, :] * stride_ok,
        acc.to(tl.bfloat16), mask=offs_m[:, None] < N_CTX,
    )


def _triton_attn_fwd(q, k, v, window_size):
    B, H, L, D = q.shape
    o        = torch.empty_like(q, dtype=torch.bfloat16)
    sm_scale = 1.0 / math.sqrt(D)
    BM, BN   = 64, 64
    BD       = triton.next_power_of_2(D)
    WIN      = window_size if (window_size and window_size > 0) else 0
    _fwd_attn_kernel[(triton.cdiv(L, BM), B * H)](
        q, k, v, o, sm_scale,
        q.stride(0), q.stride(1), q.stride(2), q.stride(3),
        k.stride(0), k.stride(1), k.stride(2), k.stride(3),
        v.stride(0), v.stride(1), v.stride(2), v.stride(3),
        o.stride(0), o.stride(1), o.stride(2), o.stride(3),
        H, L, WIN, BLOCK_M=BM, BLOCK_N=BN, BLOCK_D=BD,
    )
    return o


# block-mask cache for flex_attention backward (v3)
_block_mask_cache: dict = {}


def _get_block_mask(L: int, window_size: int, device):
    key = (L, window_size, device)
    if key not in _block_mask_cache:
        if window_size and window_size > 0:
            def mask_mod(b, h, q_idx, kv_idx):
                return (kv_idx <= q_idx) & (kv_idx > q_idx - window_size)
        else:
            def mask_mod(b, h, q_idx, kv_idx):
                return kv_idx <= q_idx
        _block_mask_cache[key] = create_block_mask(
            mask_mod, B=None, H=None, Q_LEN=L, KV_LEN=L, device=device
        )
    return _block_mask_cache[key]


# dense-mask fallback (only used when flex_attention is unavailable)
_window_mask_cache: dict = {}


def _get_window_mask(L: int, window_size: int, device):
    key = (L, window_size, device)
    if key not in _window_mask_cache:
        idx  = torch.arange(L, device=device)
        diff = idx.view(-1, 1) - idx.view(1, -1)
        mask = (diff >= 0) & (diff < window_size) if (window_size and window_size > 0) else diff >= 0
        _window_mask_cache[key] = mask
    return _window_mask_cache[key]


class TritonWindowAttentionFn(torch.autograd.Function):
    """fwd = fused triton kernel, bwd = flex_attention block_mask recompute."""

    @staticmethod
    def forward(ctx, q, k, v, window_size):
        q, k, v = q.contiguous(), k.contiguous(), v.contiguous()
        out = _triton_attn_fwd(q, k, v, window_size)
        ctx.save_for_backward(q, k, v)
        ctx.window_size = window_size
        return out

    @staticmethod
    def backward(ctx, dout):
        q, k, v     = ctx.saved_tensors
        window_size = ctx.window_size
        L           = q.shape[2]
        with torch.enable_grad():
            qd = q.detach().requires_grad_(True)
            kd = k.detach().requires_grad_(True)
            vd = v.detach().requires_grad_(True)
            if HAS_FLEX_ATTN:
                bm  = _get_block_mask(L, window_size, q.device)
                out = flex_attention(qd, kd, vd, block_mask=bm)
            else:
                mask = _get_window_mask(L, window_size, q.device)
                out  = F.scaled_dot_product_attention(qd, kd, vd, attn_mask=mask)
            dq, dk, dv = torch.autograd.grad(out, (qd, kd, vd), dout)
        return dq, dk, dv, None


def triton_attention(q, k, v, window_size: int = 0):
    return TritonWindowAttentionFn.apply(q, k, v, window_size)


# ── 4. Fused grouped-GEMM MoE dispatch ───────────────────────────────────────
_moe_autotune_configs = [
    triton.Config({"BLOCK_N": 64,  "BLOCK_K": 32}, num_warps=4, num_stages=3),
    triton.Config({"BLOCK_N": 128, "BLOCK_K": 32}, num_warps=8, num_stages=3),
    triton.Config({"BLOCK_N": 128, "BLOCK_K": 64}, num_warps=8, num_stages=4),
    triton.Config({"BLOCK_N": 64,  "BLOCK_K": 64}, num_warps=4, num_stages=4),
]


@triton.autotune(configs=_moe_autotune_configs, key=["K", "N"])
@triton.jit
def _moe_gemm_kernel(
    A_ptr, B_ptr, C_ptr, block_expert_ptr,
    M_padded, K, N,
    stride_am, stride_ak,
    stride_be, stride_bk, stride_bn,
    stride_cm, stride_cn,
    BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr, BLOCK_K: tl.constexpr,
):
    pid_m = tl.program_id(0)
    pid_n = tl.program_id(1)
    e     = tl.load(block_expert_ptr + pid_m).to(tl.int64)

    offs_m = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
    offs_n = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
    offs_k = tl.arange(0, BLOCK_K)
    m_mask = offs_m < M_padded
    n_mask = offs_n < N

    a_ptrs = A_ptr + offs_m[:, None] * stride_am + offs_k[None, :] * stride_ak
    b_ptrs = B_ptr + e * stride_be + offs_k[:, None] * stride_bk + offs_n[None, :] * stride_bn

    acc = tl.zeros((BLOCK_M, BLOCK_N), dtype=tl.float32)
    for k0 in range(0, K, BLOCK_K):
        k_mask = (k0 + offs_k) < K
        a = tl.load(a_ptrs, mask=m_mask[:, None] & k_mask[None, :], other=0.0)
        b = tl.load(b_ptrs, mask=k_mask[:, None] & n_mask[None, :], other=0.0)
        acc    = tl.dot(a, b, acc)
        a_ptrs += BLOCK_K * stride_ak
        b_ptrs += BLOCK_K * stride_bk

    tl.store(
        C_ptr + offs_m[:, None] * stride_cm + offs_n[None, :] * stride_cn,
        acc.to(tl.bfloat16), mask=m_mask[:, None] & n_mask[None, :],
    )


def _grouped_linear_raw(A, W, block_expert, M_padded, transpose, BM):
    E, OUT, IN = W.shape
    if not transpose:
        K, N       = IN, OUT
        stride_bk  = W.stride(2)
        stride_bn  = W.stride(1)
    else:
        K, N       = OUT, IN
        stride_bk  = W.stride(1)
        stride_bn  = W.stride(2)

    C    = torch.empty((M_padded, N), device=A.device, dtype=torch.bfloat16)
    grid = lambda META: (triton.cdiv(M_padded, BM), triton.cdiv(N, META["BLOCK_N"]))
    _moe_gemm_kernel[grid](
        A, W, C, block_expert, M_padded, K, N,
        A.stride(0), A.stride(1),
        W.stride(0), stride_bk, stride_bn,
        C.stride(0), C.stride(1),
        BLOCK_M=BM,
    )
    return C


@triton.autotune(configs=_moe_autotune_configs, key=["K", "N"])
@triton.jit
def _moe_dw_kernel(
    A_ptr, DC_ptr, DW_ptr, block_expert_ptr,
    M_padded, K, N,
    stride_am, stride_ak,
    stride_dcm, stride_dcn,
    stride_dwe, stride_dwn, stride_dwk,
    BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr, BLOCK_K: tl.constexpr,
):
    pid_m = tl.program_id(0)
    pid_n = tl.program_id(1)
    pid_k = tl.program_id(2)
    e     = tl.load(block_expert_ptr + pid_m).to(tl.int64)

    offs_m = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
    offs_n = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
    offs_k = pid_k * BLOCK_K + tl.arange(0, BLOCK_K)
    m_mask = offs_m < M_padded
    n_mask = offs_n < N
    k_mask = offs_k < K

    a  = tl.load(A_ptr  + offs_m[:, None] * stride_am  + offs_k[None, :] * stride_ak,
                 mask=m_mask[:, None] & k_mask[None, :], other=0.0)
    dc = tl.load(DC_ptr + offs_m[:, None] * stride_dcm + offs_n[None, :] * stride_dcn,
                 mask=m_mask[:, None] & n_mask[None, :], other=0.0)

    tl.atomic_add(
        DW_ptr + e * stride_dwe + offs_n[:, None] * stride_dwn + offs_k[None, :] * stride_dwk,
        tl.dot(tl.trans(dc), a),
        mask=n_mask[:, None] & k_mask[None, :],
    )


def _grouped_dw_raw(A, dC, block_expert, E, OUT, IN, M_padded, BM):
    DW   = torch.zeros((E, OUT, IN), device=A.device, dtype=torch.float32)
    grid = lambda META: (
        triton.cdiv(M_padded, BM),
        triton.cdiv(OUT, META["BLOCK_N"]),
        triton.cdiv(IN,  META["BLOCK_K"]),
    )
    _moe_dw_kernel[grid](
        A, dC, DW, block_expert, M_padded, IN, OUT,
        A.stride(0), A.stride(1),
        dC.stride(0), dC.stride(1),
        DW.stride(0), DW.stride(1), DW.stride(2),
        BLOCK_M=BM,
    )
    return DW


class GroupedLinearFn(torch.autograd.Function):
    @staticmethod
    def forward(ctx, A, W, block_expert, padded_offsets, M_padded, BM):
        A = A.contiguous().to(torch.bfloat16)
        C = _grouped_linear_raw(A, W, block_expert, M_padded, False, BM)
        ctx.save_for_backward(A, W, block_expert, padded_offsets)
        ctx.M_padded = M_padded
        ctx.BM       = BM
        return C

    @staticmethod
    def backward(ctx, dC):
        A, W, block_expert, _ = ctx.saved_tensors
        dC = dC.contiguous().to(torch.bfloat16)
        dA = _grouped_linear_raw(dC, W, block_expert, ctx.M_padded, True, ctx.BM) \
             if ctx.needs_input_grad[0] else None
        dW = _grouped_dw_raw(A, dC, block_expert, W.shape[0], W.shape[1], W.shape[2],
                             ctx.M_padded, ctx.BM).to(W.dtype) \
             if ctx.needs_input_grad[1] else None
        return dA, dW, None, None, None, None


def moe_align_block_size(expert_ids, num_experts, block_size, device):
    counts        = torch.bincount(expert_ids, minlength=num_experts)
    padded_counts = ((counts + block_size - 1) // block_size) * block_size

    padded_offsets      = torch.zeros(num_experts + 1, dtype=torch.long, device=device)
    padded_offsets[1:]  = torch.cumsum(padded_counts, dim=0)
    orig_offsets        = torch.zeros(num_experts + 1, dtype=torch.long, device=device)
    orig_offsets[1:]    = torch.cumsum(counts, dim=0)

    total_padded         = int(padded_offsets[-1].item())
    sort_idx             = torch.argsort(expert_ids, stable=True)
    num_blocks_per_expert= padded_counts // block_size
    block_expert         = torch.repeat_interleave(
        torch.arange(num_experts, device=device), num_blocks_per_expert
    )

    n_rows               = expert_ids.numel()
    arange_total         = torch.arange(n_rows, device=device)
    sorted_expert_of_row = expert_ids[sort_idx]
    row_within_expert    = arange_total - orig_offsets[sorted_expert_of_row]
    dest                 = padded_offsets[sorted_expert_of_row] + row_within_expert

    perm       = torch.full((total_padded,), -1, dtype=torch.long, device=device)
    perm[dest] = sort_idx
    return perm, block_expert, total_padded, padded_offsets


class FusedExpertTier(nn.Module):
    """Single-tier fused grouped-GEMM expert compute."""

    def __init__(self, n_experts: int, d_model: int, hidden_dim: int, block_m: int = 64):
        super().__init__()
        self.n_experts  = n_experts
        self.hidden_dim = hidden_dim
        self.block_m    = block_m
        self.W_gate_up  = nn.Parameter(torch.empty(n_experts, 2 * hidden_dim, d_model))
        self.W_down     = nn.Parameter(torch.empty(n_experts, d_model, hidden_dim))
        nn.init.normal_(self.W_gate_up, std=0.02)
        nn.init.normal_(self.W_down,    std=0.02)

    def forward(self, x_flat, top_idx, top_gate, tier_weight):
        N, D   = x_flat.shape
        k      = top_idx.shape[1]
        E      = self.n_experts
        device = x_flat.device
        BM     = self.block_m

        expert_ids_flat = top_idx.reshape(-1)
        gate_flat       = (top_gate * tier_weight).reshape(-1)
        token_idx_flat  = torch.arange(N, device=device).unsqueeze(1).expand(N, k).reshape(-1)

        perm, block_expert, total_padded, padded_offsets = moe_align_block_size(
            expert_ids_flat, E, BM, device
        )

        valid      = perm >= 0
        gather_idx = perm.clamp_min(0)
        src_token  = token_idx_flat[gather_idx]
        A_padded   = x_flat[src_token] * valid.unsqueeze(1).to(x_flat.dtype)

        gate_up = GroupedLinearFn.apply(A_padded, self.W_gate_up, block_expert, padded_offsets, total_padded, BM)
        H       = self.hidden_dim
        down    = GroupedLinearFn.apply(F.silu(gate_up[:, :H]) * gate_up[:, H:], self.W_down, block_expert, padded_offsets, total_padded, BM)

        gate_vals = (gate_flat[gather_idx] * valid.to(gate_flat.dtype)).unsqueeze(1)
        out       = torch.zeros(N, D, dtype=x_flat.dtype, device=device)
        out.index_add_(0, src_token, (down * gate_vals.to(down.dtype)))
        return out


# ── 5. Muon with 3-D expert tensor support ───────────────────────────────────
def zeropower_via_newtonschulz5(G: torch.Tensor, steps: int = 5) -> torch.Tensor:
    assert G.ndim == 2
    a, b, c = 3.4445, -4.7750, 2.0315
    X = G.bfloat16()
    if X.size(0) > X.size(1):
        X = X.T
    X = X / (X.norm() + 1e-7)
    for _ in range(steps):
        A = X @ X.T
        X = a * X + (b * A + c * A @ A) @ X
    if G.size(0) > G.size(1):
        X = X.T
    return X


class Muon(torch.optim.Optimizer):
    def __init__(self, params, lr=0.02, momentum=0.95, weight_decay=0.0, ns_steps=5):
        params = list(params)
        for p in params:
            assert p.ndim in (2, 3), f"Muon: expected 2D/3D param, got {tuple(p.shape)}"
        super().__init__(params, dict(lr=lr, momentum=momentum,
                                     weight_decay=weight_decay, ns_steps=ns_steps))

    @torch.no_grad()
    def step(self):
        for group in self.param_groups:
            lr, mom, wd, ns = group["lr"], group["momentum"], group["weight_decay"], group["ns_steps"]
            for p in group["params"]:
                if p.grad is None:
                    continue
                g     = p.grad
                state = self.state[p]
                if "buf" not in state:
                    state["buf"] = torch.zeros_like(g)
                buf = state["buf"]
                buf.mul_(mom).add_(g)
                g = g.add(buf, alpha=mom)
                if wd > 0:
                    p.mul_(1 - lr * wd)
                if p.ndim == 2:
                    u     = zeropower_via_newtonschulz5(g, steps=ns)
                    scale = 0.2 * math.sqrt(max(p.size(0), p.size(1)))
                else:
                    u = torch.stack([zeropower_via_newtonschulz5(g[e], steps=ns)
                                     for e in range(p.size(0))])
                    scale = 0.2 * math.sqrt(max(p.size(1), p.size(2)))
                p.add_(u.to(p.dtype), alpha=-lr * scale)


log.info(
    "[triton] RMSNorm / RoPE / windowed-attn (flex_attention bwd) / "
    "grouped-GEMM MoE (fwd+dW autotuned) / Muon(2D+3D) — all ready"
)


# ══════════════════════════════════════════════════════════════════════════════
#  NaN HUNTER  (debug utility — not called in normal training)
# ══════════════════════════════════════════════════════════════════════════════
def install_nan_hooks(model: nn.Module):
    handles = []
    for name, module in model.named_modules():
        if not list(module.children()):
            def _hook(m, inp, out, _name=name):
                for i, o in enumerate((out if isinstance(out, (tuple, list)) else (out,))):
                    if isinstance(o, torch.Tensor) and o.dtype.is_floating_point:
                        if torch.isnan(o).any() or torch.isinf(o).any():
                            raise RuntimeError(f"NaN/Inf in {_name} output[{i}]")
            handles.append(module.register_forward_hook(_hook))
    return handles


def debug_one_batch(model, cfg, device, B=2, L=512):
    model.train(); model.set_step(0)
    handles = install_nan_hooks(model)
    dummy   = torch.randint(0, cfg.vocab_size, (B, L), device=device)
    try:
        with torch.amp.autocast("cuda", dtype=torch.bfloat16):
            out = model(dummy, targets=dummy)
        print(f"✅ forward clean — loss={out[1].item():.4f}")
    except RuntimeError as e:
        print(f"🔴 {e}")
    finally:
        for h in handles: h.remove()


# ══════════════════════════════════════════════════════════════════════════════
#  MODEL BUILDING BLOCKS
# ══════════════════════════════════════════════════════════════════════════════
class GroupedQueryAttention(nn.Module):
    def __init__(self, cfg: CascadeConfig, layer_idx: int):
        super().__init__()
        self.nh          = cfg.n_heads
        self.nkv         = cfg.n_kv_heads
        self.hd          = cfg.head_dim
        self.ng          = cfg.n_heads // cfg.n_kv_heads
        self.is_local    = (layer_idx % 2 == 0)
        self.window_size = cfg.local_window_size if self.is_local else 0

        D   = cfg.n_heads    * cfg.head_dim
        Dkv = cfg.n_kv_heads * cfg.head_dim

        self.q = nn.Linear(cfg.d_model, D,   bias=False)
        self.k = nn.Linear(cfg.d_model, Dkv, bias=False)
        self.v = nn.Linear(cfg.d_model, Dkv, bias=False)
        self.o = nn.Linear(D, cfg.d_model,   bias=False)

        self.q_norm = RMSNorm(self.hd)
        self.k_norm = RMSNorm(self.hd)

        for lin in (self.q, self.k, self.v):
            nn.init.normal_(lin.weight, std=0.02)
        nn.init.normal_(self.o.weight, std=0.02 / math.sqrt(2 * cfg.n_layers))

    def forward(self, x, cos, sin):
        B, L, _ = x.shape
        q = self.q_norm(self.q(x).view(B, L, self.nh,  self.hd))
        k = self.k_norm(self.k(x).view(B, L, self.nkv, self.hd))
        v =             self.v(x).view(B, L, self.nkv, self.hd)

        q, k = apply_rope(q, k, cos, sin)

        q = q.transpose(1, 2).contiguous()
        k = k.transpose(1, 2).repeat_interleave(self.ng, 1).contiguous()
        v = v.transpose(1, 2).repeat_interleave(self.ng, 1).contiguous()

        return self.o(
            triton_attention(q, k, v, window_size=self.window_size)
            .transpose(1, 2).contiguous().view(B, L, -1)
        )


class HierarchicalMoE(nn.Module):
    def __init__(self, cfg: CascadeConfig):
        super().__init__()
        self.cfg     = cfg
        self.n_nano  = cfg.n_nano_experts
        self.n_midi  = cfg.n_midi_experts
        self.n_macro = cfg.n_macro_experts

        self.tier_router  = nn.Linear(cfg.d_model, 3,             bias=False)
        self.nano_router  = nn.Linear(cfg.d_model, self.n_nano,   bias=False)
        self.midi_router  = nn.Linear(cfg.d_model, self.n_midi,   bias=False)
        self.macro_router = nn.Linear(cfg.d_model, self.n_macro,  bias=False)
        nn.init.normal_(self.tier_router.weight, std=0.01)
        for r in (self.nano_router, self.midi_router, self.macro_router):
            nn.init.normal_(r.weight, std=0.02)

        self.nano_tier  = FusedExpertTier(self.n_nano,  cfg.d_model, cfg.nano_hidden)
        self.midi_tier  = FusedExpertTier(self.n_midi,  cfg.d_model, cfg.midi_hidden)
        self.macro_tier = FusedExpertTier(self.n_macro, cfg.d_model, cfg.macro_hidden)

        for name, n in [("nano_load", self.n_nano), ("midi_load", self.n_midi),
                        ("macro_load", self.n_macro), ("token_count", 1)]:
            self.register_buffer(name, torch.zeros(n, dtype=torch.float32), persistent=False)

    def _apply(self, fn, recurse=True):
        saved = {k: getattr(self, k).clone()
                 for k in ("nano_load", "midi_load", "macro_load", "token_count")}
        super()._apply(fn, recurse=recurse)
        dev = self.nano_load.device
        for k, v in saved.items():
            setattr(self, k, v.float().to(dev))
        return self

    def forward(self, x, step: int):
        B, L, D = x.shape
        N, cfg  = B * L, self.cfg
        xf      = x.reshape(N, D)

        # ── routers ──────────────────────────────────────────────────────────
        def _maybe_noise(t):
            if self.training and step < cfg.router_noise_steps:
                return t + cfg.router_noise_std * torch.randn_like(t)
            return t

        tier_probs  = F.softmax(_maybe_noise(self.tier_router(xf)).float(),  dim=-1)
        nano_soft   = F.softmax(_maybe_noise(self.nano_router(xf)).float(),  dim=-1)
        midi_soft   = F.softmax(_maybe_noise(self.midi_router(xf)).float(),  dim=-1)
        macro_soft  = F.softmax(_maybe_noise(self.macro_router(xf)).float(), dim=-1)

        nano_g,  nano_idx  = torch.topk(nano_soft,  cfg.nano_top_k,  dim=-1)
        midi_g,  midi_idx  = torch.topk(midi_soft,  cfg.midi_top_k,  dim=-1)
        macro_g, macro_idx = torch.topk(macro_soft, cfg.macro_top_k, dim=-1)

        nano_g  = nano_g  / nano_g.sum( -1, keepdim=True).clamp_min(1e-9)
        midi_g  = midi_g  / midi_g.sum( -1, keepdim=True).clamp_min(1e-9)
        macro_g = macro_g / macro_g.sum(-1, keepdim=True).clamp_min(1e-9)

        nano_w, midi_w, macro_w = tier_probs[:, 0:1], tier_probs[:, 1:2], tier_probs[:, 2:3]
        if self.training and step < cfg.macro_warmup_steps:
            macro_w = torch.clamp(macro_w + 0.3, 0.0, 1.0)
            s       = (nano_w + midi_w + macro_w).clamp_min(1e-9)
            nano_w, midi_w, macro_w = nano_w / s, midi_w / s, macro_w / s

        # ── load tracking ────────────────────────────────────────────────────
        with torch.no_grad():
            ones = lambda n: torch.ones(n, device=x.device, dtype=torch.float32)
            self.nano_load.scatter_add_ (0, nano_idx.reshape(-1),  ones(nano_idx.numel()))
            self.midi_load.scatter_add_ (0, midi_idx.reshape(-1),  ones(midi_idx.numel()))
            self.macro_load.scatter_add_(0, macro_idx.reshape(-1), ones(macro_idx.numel()))
            self.token_count += float(N)

        # ── expert compute ───────────────────────────────────────────────────
        out = (  self.nano_tier( xf, nano_idx,  nano_g,  nano_w)
               + self.midi_tier( xf, midi_idx,  midi_g,  midi_w)
               + self.macro_tier(xf, macro_idx, macro_g, macro_w))

        # ── aux losses ───────────────────────────────────────────────────────
        zloss = ((torch.logsumexp(nano_soft.log(),  -1) ** 2).mean()
               + (torch.logsumexp(midi_soft.log(),  -1) ** 2).mean()
               + (torch.logsumexp(macro_soft.log(), -1) ** 2).mean()) / 3.0

        def _bal(soft, idx, top_g, tier_w, cost):
            full = torch.zeros(N, soft.shape[1], device=x.device, dtype=torch.float32)
            full.scatter_(1, idx, (top_g * tier_w).float())
            return cost * ((full > 0).float().mean(0) * soft.mean(0)).sum()

        balance = (
            _bal(nano_soft,  nano_idx,  nano_g,  nano_w,  cfg.nano_cost_weight)
          + _bal(midi_soft,  midi_idx,  midi_g,  midi_w,  cfg.midi_cost_weight)
          + _bal(macro_soft, macro_idx, macro_g, macro_w, cfg.macro_cost_weight)
        ) * cfg.total_experts_per_layer / 3.0

        aux_loss = cfg.zloss_coeff * zloss + cfg.balance_coeff * balance
        return out.reshape(B, L, D), aux_loss

    @torch.no_grad()
    def read_reset_stats(self):
        total = self.token_count.item()
        if total <= 0:
            return [], [], [], 0, 0
        nano_f  = (self.nano_load  / total).tolist()
        midi_f  = (self.midi_load  / total).tolist()
        macro_f = (self.macro_load / total).tolist()
        dead    = int((self.nano_load  == 0).sum()
                    + (self.midi_load  == 0).sum()
                    + (self.macro_load == 0).sum())
        slots   = self.n_nano + self.n_midi + self.n_macro
        self.nano_load.zero_()
        self.midi_load.zero_()
        self.macro_load.zero_()
        self.token_count.zero_()
        return nano_f, midi_f, macro_f, dead, slots


class CascadeBlock(nn.Module):
    def __init__(self, cfg: CascadeConfig, layer_idx: int):
        super().__init__()
        self.attn_norm = RMSNorm(cfg.d_model)
        self.ffn_norm  = RMSNorm(cfg.d_model)
        self.attn      = GroupedQueryAttention(cfg, layer_idx)
        self.ffn       = HierarchicalMoE(cfg)

    def forward(self, x, cos, sin, step):
        x = x + self.attn(self.attn_norm(x), cos, sin)
        ffn_out, aux = self.ffn(self.ffn_norm(x), step)
        return x + ffn_out, aux


class CascadeFormer(nn.Module):
    def __init__(self, cfg: CascadeConfig):
        super().__init__()
        self.cfg     = cfg
        self.embed   = nn.Embedding(cfg.vocab_size, cfg.d_model)
        self.layers  = nn.ModuleList([CascadeBlock(cfg, i) for i in range(cfg.n_layers)])
        self.norm    = RMSNorm(cfg.d_model)
        self.lm_head = nn.Linear(cfg.d_model, cfg.vocab_size, bias=False)
        self.lm_head.weight = self.embed.weight          # weight tying

        nn.init.normal_(self.embed.weight, std=0.02)

        cos, sin = precompute_freqs_cis(cfg.head_dim, cfg.max_len, theta=cfg.rope_theta)
        self.register_buffer("rope_cos", cos, persistent=False)
        self.register_buffer("rope_sin", sin, persistent=False)

        self._step = 0

        n_local = sum(1 for l in self.layers if l.attn.is_local)
        log.info(f"[model] {cfg.n_layers} layers | "
                 f"{n_local} local-attn (w={cfg.local_window_size}) + "
                 f"{cfg.n_layers - n_local} global-attn")
        log.info(f"[model] {cfg.total_experts_per_layer} experts/layer | "
                 f"{cfg.n_nano_experts}×NANO({cfg.nano_hidden}d) + "
                 f"{cfg.n_midi_experts}×MIDI({cfg.midi_hidden}d) + "
                 f"{cfg.n_macro_experts}×MACRO({cfg.macro_hidden}d)")

    def set_step(self, s: int): self._step = s

    def forward(self, input_ids, targets=None):
        B, L  = input_ids.shape
        x     = self.embed(input_ids)
        cos   = self.rope_cos[:L]
        sin   = self.rope_sin[:L]

        aux_total = x.new_zeros(())
        for layer in self.layers:
            x, aux    = layer(x, cos, sin, self._step)
            aux_total = aux_total + aux

        logits = self.lm_head(self.norm(x))

        if targets is None:
            return logits, None

        lm_loss = F.cross_entropy(
            logits[:, :-1].contiguous().view(-1, self.cfg.vocab_size),
            targets[:, 1:].contiguous().view(-1),
            ignore_index=-1,
        )
        total_loss = lm_loss + aux_total / self.cfg.n_layers
        return logits, total_loss, lm_loss.detach(), (aux_total / self.cfg.n_layers).detach()

    def moe_modules(self):
        for layer in self.layers:
            yield layer.ffn

    @torch.no_grad()
    def moe_read_stats(self):
        all_n, all_m, all_mc, dead, slots = [], [], [], 0, 0
        for moe in self.moe_modules():
            n, m, mc, d, s = moe.read_reset_stats()
            all_n.extend(n); all_m.extend(m); all_mc.extend(mc)
            dead += d; slots += s
        return all_n, all_m, all_mc, dead, slots

    def count_params(self) -> int:
        seen, total = set(), 0
        for p in self.parameters():
            if id(p) not in seen:
                seen.add(id(p)); total += p.numel()
        return total


# ══════════════════════════════════════════════════════════════════════════════
#  FP8
# ══════════════════════════════════════════════════════════════════════════════
_FP8_SKIP = ("tier_router", "nano_router", "midi_router", "macro_router", "lm_head", "embed")


def fp8_capable_gpu() -> bool:
    return torch.cuda.is_available() and torch.cuda.get_device_capability(0)[0] >= 9


def resolve_use_fp8(cfg: CascadeConfig) -> bool:
    if cfg.use_fp8 == "off":
        return False
    if cfg.use_fp8 == "on":
        if not HAS_TORCHAO: log.warning("[fp8] torchao missing — bf16"); return False
        if not fp8_capable_gpu(): log.warning("[fp8] pre-Hopper GPU — bf16"); return False
        return True
    ok = HAS_TORCHAO and fp8_capable_gpu()
    log.info(f"[fp8] auto → {'FP8' if ok else 'BF16'}")
    return ok


def apply_fp8(model: nn.Module, cfg: CascadeConfig) -> nn.Module:
    if not resolve_use_fp8(cfg):
        return model
    convert_to_float8_training(
        model,
        config=Float8LinearConfig.from_recipe_name("rowwise"),
        module_filter_fn=lambda m, fqn: (
            isinstance(m, nn.Linear) and not any(s in fqn for s in _FP8_SKIP)
        ),
    )
    log.info("[fp8] model converted")
    return model


# ══════════════════════════════════════════════════════════════════════════════
#  OPTIMIZERS
# ══════════════════════════════════════════════════════════════════════════════
def build_optimizers(model: nn.Module, cfg: CascadeConfig):
    muon_p, wd_p, no_wd_p, seen = [], [], [], set()
    for name, p in model.named_parameters():
        if id(p) in seen or not p.requires_grad:
            continue
        seen.add(id(p))
        is_head = ("embed" in name) or ("lm_head" in name)
        if p.ndim in (2, 3) and not is_head:
            muon_p.append(p)
        elif p.ndim >= 2:
            wd_p.append(p)
        else:
            no_wd_p.append(p)

    muon_opt = Muon(muon_p, lr=cfg.muon_lr, momentum=cfg.muon_momentum,
                    weight_decay=cfg.weight_decay)

    adamw_groups = [
        {"params": wd_p,    "weight_decay": cfg.weight_decay},
        {"params": no_wd_p, "weight_decay": 0.0},
    ]
    if HAS_BNB:
        adamw_opt = bnb.optim.AdamW8bit(
            adamw_groups, lr=cfg.adamw_lr, betas=(cfg.beta1, cfg.beta2), eps=1e-8
        )
        log.info("[optim] Muon + 8-bit AdamW (bitsandbytes)")
    else:
        adamw_opt = torch.optim.AdamW(
            adamw_groups, lr=cfg.adamw_lr, betas=(cfg.beta1, cfg.beta2),
            eps=1e-8, fused=True,
        )
        log.info("[optim] Muon + fused AdamW")

    log.info(f"[optim] Muon={sum(p.numel() for p in muon_p)/1e6:.1f}M  "
             f"AdamW={sum(p.numel() for p in wd_p + no_wd_p)/1e6:.1f}M")
    return muon_opt, adamw_opt


def get_lr(step: int, warmup: int, max_steps: int, peak: float, minimum: float) -> float:
    if step < warmup:
        return peak * (step + 1) / warmup
    if step >= max_steps:
        return minimum
    t = (step - warmup) / (max_steps - warmup)
    return minimum + 0.5 * (peak - minimum) * (1 + math.cos(math.pi * t))


# ══════════════════════════════════════════════════════════════════════════════
#  BATCH SIZE SEARCH
# ══════════════════════════════════════════════════════════════════════════════
MIN_MICRO        = 2
MAX_MICRO        = 128
VRAM_SAFETY_FRAC = 0.70


def _try_bs(model, cfg, device, bs, muon_opt, adamw_opt) -> bool:
    try:
        torch.cuda.empty_cache()
        torch.cuda.reset_peak_memory_stats()
        dummy = torch.randint(0, cfg.vocab_size, (bs, cfg.max_len), device=device)
        with torch.amp.autocast("cuda", dtype=torch.bfloat16):
            loss = model(dummy, targets=dummy)[1]
        loss.backward()
        muon_opt.step(); adamw_opt.step()
        muon_opt.zero_grad(set_to_none=True); adamw_opt.zero_grad(set_to_none=True)
        frac = torch.cuda.max_memory_allocated() / (vram_total_gb() * 1024**3)
        torch.cuda.reset_peak_memory_stats(); torch.cuda.empty_cache()
        return frac <= VRAM_SAFETY_FRAC
    except torch.cuda.OutOfMemoryError:
        torch.cuda.empty_cache()
        muon_opt.zero_grad(set_to_none=True); adamw_opt.zero_grad(set_to_none=True)
        return False


def find_optimal_batch(model, cfg, device, muon_opt, adamw_opt) -> int:
    log.info(f"[batch] searching best micro-batch (≤{VRAM_SAFETY_FRAC:.0%} VRAM) ...")
    if not _try_bs(model, cfg, device, MIN_MICRO, muon_opt, adamw_opt):
        log.warning(f"[batch] bs={MIN_MICRO} already tight — using it anyway")
        muon_opt.state.clear(); adamw_opt.state.clear(); torch.cuda.empty_cache()
        return MIN_MICRO
    lo, hi, best = MIN_MICRO, MAX_MICRO, MIN_MICRO
    while lo <= hi:
        mid = (lo + hi) // 2
        if _try_bs(model, cfg, device, mid, muon_opt, adamw_opt):
            best = mid; log.info(f"[batch]   {mid:4d} ✓"); lo = mid + 1
        else:
            log.info(f"[batch]   {mid:4d} ✗"); hi = mid - 1
    log.info(f"[batch] → micro_batch = {best}")
    muon_opt.state.clear(); adamw_opt.state.clear(); torch.cuda.empty_cache()
    return best


# ══════════════════════════════════════════════════════════════════════════════
#  CHECKPOINT I/O
# ══════════════════════════════════════════════════════════════════════════════
def save_ckpt(model, muon_opt, adamw_opt, step, epoch, cfg, val_loss) -> bool:
    base      = f"session{SESSION_ID:03d}_s{step:07d}"
    f_model   = os.path.join(TEMP_CKPT_DIR, f"{base}.model.pt")
    f_meta    = os.path.join(TEMP_CKPT_DIR, f"{base}.meta.pt")
    try:
        torch.save({k: v.contiguous() for k, v in model.state_dict().items()}, f_model)
        torch.save(dict(
            step=step, epoch=epoch, val_loss=val_loss,
            config=asdict(cfg),
            muon_optimizer=muon_opt.state_dict(),
            adamw_optimizer=adamw_opt.state_dict(),
            session_id=SESSION_ID,
        ), f_meta)
        ok = upload_to_hf(f_model, f"{base}.model.pt") and upload_to_hf(f_meta, f"{base}.meta.pt")
        os.remove(f_model); os.remove(f_meta)
        if ok: log.info(f"[ckpt] ✓ {base}")
        else:  log.error(f"[ckpt] upload incomplete for {base}")
        return ok
    except Exception as e:
        log.error(f"[ckpt] save error: {e}")
        for f in (f_model, f_meta):
            try: os.remove(f)
            except FileNotFoundError: pass
        return False


def save_final(model, step, epoch, cfg, val_loss) -> None:
    base    = f"cascadeformer_session{SESSION_ID:03d}_final_s{step:07d}"
    f_model = os.path.join(TEMP_CKPT_DIR, f"{base}.safetensors")
    f_cfg   = os.path.join(TEMP_CKPT_DIR, f"{base}_config.json")
    try:
        sd = {k: v.detach().clone().contiguous() for k, v in model.state_dict().items()}
        if HAS_ST:
            st_save(sd, f_model)
        else:
            f_model = f_model.replace(".safetensors", ".model.pt")
            torch.save(sd, f_model)
        with open(f_cfg, "w") as fh:
            json.dump({**asdict(cfg), "final_step": step,
                       "final_epoch": epoch, "final_val_loss": val_loss,
                       "session_id": SESSION_ID}, fh, indent=2)
        upload_to_hf(f_model, os.path.basename(f_model))
        upload_to_hf(f_cfg,   os.path.basename(f_cfg))
        os.remove(f_model); os.remove(f_cfg)
        log.info(f"[final] ✓ {base}")
    except Exception as e:
        log.error(f"[final] save error: {e}")
        for f in (f_model, f_cfg):
            try: os.remove(f)
            except FileNotFoundError: pass


def load_ckpt(base_name, model, muon_opt, adamw_opt, device, cfg):
    f_model = hf_hub_download(repo_id=HF_MODEL_REPO, filename=f"{base_name}.model.pt",
                               repo_type="model", cache_dir=TEMP_CKPT_DIR, token=HF_TOKEN)
    f_meta  = hf_hub_download(repo_id=HF_MODEL_REPO, filename=f"{base_name}.meta.pt",
                               repo_type="model", cache_dir=TEMP_CKPT_DIR, token=HF_TOKEN)

    sd = torch.load(f_model, map_location=device, weights_only=True)
    missing, unexpected = model.load_state_dict(sd, strict=False)
    if missing:     log.warning(f"[ckpt] {len(missing)} missing keys")
    if unexpected:  log.warning(f"[ckpt] {len(unexpected)} unexpected keys")

    meta = torch.load(f_meta, map_location="cpu", weights_only=False)
    for opt, key in ((muon_opt, "muon_optimizer"), (adamw_opt, "adamw_optimizer")):
        if opt and key in meta:
            try: opt.load_state_dict(meta[key])
            except Exception as e: log.warning(f"[ckpt] {key} not restored: {e}")

    log.info(f"[ckpt] resumed s={meta['step']} e={meta['epoch']} "
             f"val={meta['val_loss']:.4f} session={meta.get('session_id','?')}")
    return meta["step"], meta["epoch"], meta["val_loss"]


# ══════════════════════════════════════════════════════════════════════════════
#  VALIDATION
# ══════════════════════════════════════════════════════════════════════════════
@torch.no_grad()
def run_val(model, val_loader, device, n: int = 100) -> float:
    model.eval()
    losses = []
    it     = iter(val_loader)
    for _ in range(n):
        try:
            b = next(it).to(device, non_blocking=True)
        except StopIteration:
            break
        with torch.amp.autocast("cuda", dtype=torch.bfloat16):
            out = model(b, targets=b)
        losses.append(out[2].item() if len(out) > 2 else out[1].item())
    model.train()
    # reset MoE load buffers that accumulated during eval
    for moe in model.moe_modules():
        moe.nano_load.zero_(); moe.midi_load.zero_()
        moe.macro_load.zero_(); moe.token_count.zero_()
    return float(np.mean(losses)) if losses else float("nan")


# ══════════════════════════════════════════════════════════════════════════════
#  DISPLAY HELPERS
# ══════════════════════════════════════════════════════════════════════════════
_BARS = "▁▂▃▄▅▆▇█"


def load_bar(fracs, n_experts: int) -> str:
    return "".join(_BARS[min(7, int(f * n_experts * 4))] for f in fracs)


def _fmt_time(seconds: float) -> str:
    h = int(seconds // 3600)
    m = int((seconds % 3600) // 60)
    s = int(seconds % 60)
    return f"{h:02d}h{m:02d}m{s:02d}s"


# ══════════════════════════════════════════════════════════════════════════════
#  GRACEFUL SHUTDOWN
# ══════════════════════════════════════════════════════════════════════════════
def graceful_shutdown(model, muon_opt, adamw_opt, step, epoch, cfg,
                      best_val, device, val_loader, losses, metrics: MetricsLogger):
    log.info("=" * 64)
    log.info("GRACEFUL SHUTDOWN — final save")
    log.info("=" * 64)

    save_ckpt(model, muon_opt, adamw_opt, step, epoch, cfg,
              losses[-1] if losses else 0.0)

    fval  = run_val(model, val_loader, device, n=200)
    fppl  = math.exp(min(fval, 20))
    avg_t = float(np.mean(losses[-200:])) if losses else float("nan")

    save_final(model, step, epoch, cfg, fval)
    metrics.log_final(step=step, epoch=epoch, train_loss=avg_t,
                      val_loss=fval, val_ppl=fppl, best_val=best_val)

    report = dict(
        session_id     = SESSION_ID,
        step           = step,
        epoch          = epoch,
        train_loss     = avg_t,
        val_loss       = fval,
        val_ppl        = fppl,
        best_val       = best_val,
        elapsed_h      = elapsed_h(),
        wall_time      = _fmt_time(time.time() - TRAINING_START),
        architecture   = "CascadeFormer",
        total_params_b = model.count_params() / 1e9,
        optimizer      = "Muon+AdamW",
    )

    f_report = os.path.join(TEMP_CKPT_DIR, f"report_session{SESSION_ID:03d}_s{step}.json")
    try:
        with open(f_report, "w") as fh:
            json.dump(report, fh, indent=2)
        upload_to_hf(f_report, os.path.basename(f_report))
        os.remove(f_report)
    except Exception as e:
        log.warning(f"[shutdown] report upload failed: {e}")

    log.info("-" * 64)
    for k, v in report.items():
        log.info(f"  {k:<22}: " + (f"{v:.4f}" if isinstance(v, float) else str(v)))
    log.info("=" * 64)

    metrics.close()   # final flush to HF


# ══════════════════════════════════════════════════════════════════════════════
#  TRAIN
# ══════════════════════════════════════════════════════════════════════════════
def train():
    torch.manual_seed(42); np.random.seed(42); random.seed(42)

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    log.info(f"[env] device={device} | "
             f"GPU={torch.cuda.get_device_name(0)} | "
             f"VRAM={vram_total_gb():.0f}GB")
    log.info(f"[env] bnb={HAS_BNB} torchao={HAS_TORCHAO} "
             f"triton={HAS_TRITON} flex_attn={HAS_FLEX_ATTN} safetensors={HAS_ST}")

    ensure_session_repo_exists()
    delete_old_session_repos(keep_last_n=2)

    cfg = CascadeConfig()

    try:
        meta_path = download_dataset_file("metadata.json")
        with open(meta_path) as fh:
            meta = json.load(fh)
        actual_vocab   = meta.get("vocab_size", 32000)
        cfg.vocab_size = (actual_vocab + 63) // 64 * 64
        log.info(f"[data] vocab {actual_vocab} → padded to {cfg.vocab_size}")
    except Exception as e:
        log.info(f"[data] no metadata.json ({e}) — using default vocab={cfg.vocab_size}")

    log.info("[model] building CascadeFormer ...")
    model = CascadeFormer(cfg).to(device).to(cfg.dtype)
    model = apply_fp8(model, cfg)
    tot   = model.count_params()
    log.info(f"[model] {tot/1e9:.3f}B params | {vram_str()}")

    muon_opt, adamw_opt = build_optimizers(model, cfg)

    # ── checkpoint resume (uncomment to resume within session 3) ─────────────
    start_step, start_epoch, best_val = 0, 0, float("inf")
    latest = find_latest_checkpoint()
    if latest:
        try:
            start_step, start_epoch, best_val = load_ckpt(
                latest, model, muon_opt, adamw_opt, device, cfg
            )
        except Exception as e:
            log.error(f"[ckpt] resume failed ({e}) — fresh start")
            start_step = start_epoch = 0

    model.train()
    model.set_step(start_step)

    chosen_bs       = find_optimal_batch(model, cfg, device, muon_opt, adamw_opt)
    cfg.micro_batch = chosen_bs

    train_inf  = FixedLoader("train_tokens.npy", batch_size=chosen_bs, num_workers=16)
    val_ds     = TokenDataset("val_tokens.npy", epoch=0)
    val_loader = DataLoader(val_ds, batch_size=min(chosen_bs, 32), shuffle=False,
                            num_workers=16, pin_memory=True, drop_last=True)

    metrics = MetricsLogger()

    # ── banner ───────────────────────────────────────────────────────────────
    fp8_tag = "FP8(rowwise)" if resolve_use_fp8(cfg) else "BF16"
    log.info("=" * 64)
    log.info(f"  CascadeFormer · Session {SESSION_ID} · {tot/1e9:.2f}B params · {fp8_tag}")
    log.info(f"  d={cfg.d_model} L={cfg.n_layers} H={cfg.n_heads}/{cfg.n_kv_heads} "
             f"ctx={cfg.max_len}")
    log.info(f"  experts/layer: {cfg.n_nano_experts}×NANO({cfg.nano_hidden}) + "
             f"{cfg.n_midi_experts}×MIDI({cfg.midi_hidden}) + "
             f"{cfg.n_macro_experts}×MACRO({cfg.macro_hidden})")
    log.info(f"  effective batch: {cfg.effective_batch_tokens(chosen_bs):,} tok/step "
             f"(bs={chosen_bs} × accum={cfg.grad_accum} × ctx={cfg.max_len})")
    log.info(f"  budget: {MAX_TRAINING_HOURS}h | fresh start session {SESSION_ID}")
    log.info(f"  metrics: {metrics.local_path} (HF upload every 15 min)")
    log.info("=" * 64)

    step           = start_step
    epoch          = start_epoch
    losses: list   = []
    last_aux       = 0.0
    accum_lm       = 0.0
    accum_n        = 0
    last_ckpt_t    = time.time()
    last_metrics_t = time.time()
    t0             = time.time()

    muon_opt.zero_grad(set_to_none=True)
    adamw_opt.zero_grad(set_to_none=True)
    model.set_step(step)

    while not should_stop():

        # ── fetch batch ──────────────────────────────────────────────────────
        try:
            batch, cur_epoch = next(train_inf)
        except Exception as e:
            log.error(f"[data] fetch error: {e}")
            continue

        if cur_epoch != epoch:
            epoch = cur_epoch
            log.info(f"[data] ── epoch {epoch + 1} start @ step {step} ──")

        batch = batch.to(device, non_blocking=True)
        if batch.shape[1] > cfg.max_len:
            batch = batch[:, :cfg.max_len]

        # ── forward + backward ───────────────────────────────────────────────
        try:
            with torch.amp.autocast("cuda", dtype=torch.bfloat16):
                _, total_loss, lm_loss, aux_loss = model(batch, targets=batch)
                (total_loss / cfg.grad_accum).backward()

            if torch.isnan(lm_loss) or torch.isinf(lm_loss):
                log.error(f"[nan] lm_loss={lm_loss.item():.4f} at step {step} — skipping micro-step")
                muon_opt.zero_grad(set_to_none=True)
                adamw_opt.zero_grad(set_to_none=True)
                accum_lm = accum_n = 0
                continue

            accum_lm += lm_loss.item()
            accum_n  += 1
            if accum_n == 1:
                last_aux = aux_loss.item()

        except torch.cuda.OutOfMemoryError:
            torch.cuda.empty_cache()
            muon_opt.zero_grad(set_to_none=True)
            adamw_opt.zero_grad(set_to_none=True)
            accum_lm = accum_n = 0
            log.error("[oom] OOM on forward/backward — micro-step skipped")
            continue

        if accum_n < cfg.grad_accum:
            continue

        # ── optimizer step ───────────────────────────────────────────────────
        muon_lr  = get_lr(step, cfg.warmup_steps, cfg.total_steps, cfg.muon_lr,  cfg.muon_min_lr)
        adamw_lr = get_lr(step, cfg.warmup_steps, cfg.total_steps, cfg.adamw_lr, cfg.adamw_min_lr)
        for pg in muon_opt.param_groups:  pg["lr"] = muon_lr
        for pg in adamw_opt.param_groups: pg["lr"] = adamw_lr

        torch.nn.utils.clip_grad_norm_(model.parameters(), cfg.grad_clip)
        muon_opt.step(); adamw_opt.step()
        muon_opt.zero_grad(set_to_none=True); adamw_opt.zero_grad(set_to_none=True)

        avg_lm = accum_lm / cfg.grad_accum
        losses.append(avg_lm)
        if len(losses) > 500: losses.pop(0)

        step += 1
        model.set_step(step)
        accum_lm = accum_n = 0

        # ── logging ──────────────────────────────────────────────────────────
        if step % cfg.log_every == 0:
            elapsed      = time.time() - t0
            sps          = (step - start_step) / max(elapsed, 1e-6)
            tps          = sps * cfg.micro_batch * cfg.grad_accum * cfg.max_len
            sec_per_step = 1.0 / max(sps, 1e-9)
            avg50        = float(np.mean(losses[-50:])) if losses else 0.0
            ppl          = math.exp(min(avg_lm, 20))
            eta_steps    = cfg.total_steps - step
            eta_s        = eta_steps * sec_per_step

            nano_f, midi_f, macro_f, dead, slots = model.moe_read_stats()

            log.info(
                f"step {step:>7,} | ep {epoch + 1} | "
                f"loss {avg_lm:.4f} | avg50 {avg50:.4f} | ppl {ppl:.1f} | "
                f"aux {last_aux:.4f}"
            )
            log.info(
                f"  lr  muon={muon_lr:.2e}  adamw={adamw_lr:.2e} | "
                f"speed {tps/1e3:.0f}K tok/s  {sec_per_step:.2f}s/step | "
                f"vram {vram_str()} | "
                f"elapsed {_fmt_time(elapsed)} | "
                f"eta {_fmt_time(eta_s)} | "
                f"{remaining_h():.2f}h left"
            )
            if nano_f:
                log.info(f"  MoE NANO  [{load_bar(nano_f,  cfg.n_nano_experts)}]")
                log.info(f"  MoE MIDI  [{load_bar(midi_f,  cfg.n_midi_experts)}]")
                log.info(f"  MoE MACRO [{load_bar(macro_f, cfg.n_macro_experts)}]")
                log.info(f"  dead experts {dead}/{slots}")

            metrics.log_train(
                step=step, epoch=epoch, loss=avg_lm, avg50=avg50, ppl=ppl,
                aux_loss=last_aux, muon_lr=muon_lr, adamw_lr=adamw_lr,
                tok_per_sec=tps, sec_per_step=sec_per_step,
                moe_dead=dead, moe_slots=slots,
            )

        # ── validation ───────────────────────────────────────────────────────
        if step % cfg.eval_every == 0:
            vl      = run_val(model, val_loader, device, n=100)
            vpp     = math.exp(min(vl, 20))
            is_best = vl < best_val
            star    = " ★ new best!" if is_best else ""
            log.info(f"  [val] loss={vl:.4f} ppl={vpp:.2f}{star}")
            if is_best:
                best_val = vl
            metrics.log_val(step=step, epoch=epoch, val_loss=vl,
                            val_ppl=vpp, is_best=is_best)

        # ── step-based checkpoint ─────────────────────────────────────────────
        if step % cfg.ckpt_every == 0:
            ok = save_ckpt(model, muon_opt, adamw_opt, step, epoch, cfg,
                           losses[-1] if losses else 0.0)
            metrics.log_ckpt(step=step, epoch=epoch, ok=ok)
            metrics.flush_to_hf()
            last_ckpt_t = last_metrics_t = time.time()

        # ── time-based checkpoint (every 30 min) ─────────────────────────────
        elif time.time() - last_ckpt_t > 1800:
            ok = save_ckpt(model, muon_opt, adamw_opt, step, epoch, cfg,
                           losses[-1] if losses else 0.0)
            metrics.log_ckpt(step=step, epoch=epoch, ok=ok)
            metrics.flush_to_hf()
            last_ckpt_t = last_metrics_t = time.time()

        # ── metrics-only HF flush (every 15 min between checkpoints) ─────────
        elif time.time() - last_metrics_t > 900:
            metrics.flush_to_hf()
            last_metrics_t = time.time()

    # ── end of training ───────────────────────────────────────────────────────
    graceful_shutdown(
        model, muon_opt, adamw_opt, step, epoch, cfg,
        best_val, device, val_loader, losses, metrics,
    )


if __name__ == "__main__":
    train()