Upload folder using huggingface_hub

code/autoslm/engine/disaggregated.py

@@ -249,7 +249,6 @@ def build_accelerate_launch_cmd(
     is the default because it shards the base weights — required for the 35B-A3B whose base does not
     fit one card replicated; for small models it is still correct, just less memory-critical.
     """
-    py = python_bin or os.environ.get("AUTOSLM_PYTHON_BIN", "python")
     cmd = [
         "accelerate",
         "launch",
@@ -272,16 +271,24 @@ def build_accelerate_launch_cmd(
         # we must NOT pass --multi_gpu here. These are accelerate-launch FSDP flags (accelerate>=1.4).
         cmd += [
             "--use_fsdp",
+            # SHARD_GRAD_OP (ZeRO-2: shard gradients+optimizer, REPLICATE parameters) — NOT FULL_SHARD.
+            # TRL's per-step weight sync calls peft merge_adapter() -> get_delta_weight() ->
+            # weight_B @ weight_A; under FULL_SHARD the LoRA weights are param-sharded so each rank
+            # holds a slice and the matmul fails ("inconsistent tensor size [32768] vs [24576]").
+            # SHARD_GRAD_OP keeps params whole on every rank so the merge sees full LoRA weights, while
+            # still sharding the optimizer/grads. Fine for the dense 1-9B bases (replicated base fits);
+            # a base too big to replicate (35B) would need FULL_SHARD + a TRL patch that gathers LoRA
+            # before merge — out of scope here.
             "--fsdp_sharding_strategy",
-            "FULL_SHARD",
+            "SHARD_GRAD_OP",
             "--fsdp_auto_wrap_policy",
             "TRANSFORMER_BASED_WRAP",
-            # FULL_STATE_DICT (not SHARDED): transformers' Trainer rejects save_only_model — which
-            # GRPOConfig sets — alongside SHARDED_STATE_DICT ("save_only_model is not compatible with
-            # FSDP state dict type 'SHARDED_STATE_DICT'"). FULL gathers the (small LoRA) adapter on
-            # rank 0 at save time, which is what trainer.save_model needs anyway. Fine for the dense
-            # 1-9B models here; a 70B+ base would want SHARDED + save_only_model off, but those route
-            # to TP inference, not a sharded full-state save.
+            # use_orig_params keeps the original (un-flattened) parameter tensors so peft can read
+            # weight_A/weight_B with their real shapes during the merge.
+            "--fsdp_use_orig_params",
+            "true",
+            # FULL_STATE_DICT: transformers' Trainer rejects save_only_model (set by GRPOConfig)
+            # alongside SHARDED_STATE_DICT; FULL gathers the small LoRA adapter on rank 0 at save time.
             "--fsdp_state_dict_type",
             "FULL_STATE_DICT",
         ]
@@ -350,20 +357,41 @@ def wait_for_server_health(
     proc: subprocess.Popen | None = None,
     log_path: str | None = None,
     interval: float = 3.0,
+    on_wait=None,
+    on_wait_every: float = 60.0,
 ) -> None:
     """Block until the rollout server answers ``/health/`` 200, the timeout elapses, or the
     subprocess dies (fail fast — a dead server would otherwise hang the trainer at first generation).
     On any failure the server log tail is appended (the HTTP port stays unbound until the worker
-    finishes loading the model, so a load/OOM crash surfaces only as 'connection refused')."""
+    finishes loading the model, so a load/OOM crash surfaces only as 'connection refused').
+
+    ``on_wait`` (called every ``on_wait_every`` s while waiting) lets the caller emit a liveness
+    heartbeat during a long boot: a BIG model (35B bf16 ~70 GB + tilelang/CUDA-graph JIT) can take
+    >20 min to bind the port, and the control plane's no-heartbeat STALL detector (~25 min) would
+    otherwise kill the run mid-boot even though it is healthy-progressing."""
     url = f"http://127.0.0.1:{port}/health/"
     deadline = time.time() + timeout
     last = None
+    # Fire the FIRST boot heartbeat promptly at loop entry, not one full ``on_wait_every`` in:
+    # the poller's stall clock may already be near its limit after the work between rl_start and
+    # server launch, so a 60s-late first ping could let it kill the run before any rl_server_boot.
+    _next_ping = time.time()
     while time.time() < deadline:
+        if on_wait is not None and time.time() >= _next_ping:
+            with contextlib.suppress(Exception):
+                on_wait()
+            _next_ping = time.time() + on_wait_every
+        # ``on_wait`` (the worker's heartbeat) can BLOCK on a slow Hugging Face upload, so re-check
+        # liveness AND the deadline AFTER it returns: otherwise a blocking heartbeat would both mask
+        # a dead vllm-serve process and let the loop overrun ``timeout`` (the while-condition only
+        # re-checks at the top of the NEXT iteration).
         if proc is not None and proc.poll() is not None:
             raise RuntimeError(
                 f"vllm-serve exited (code {proc.returncode}) before becoming healthy.\n"
                 f"--- vllm-serve log tail ---\n{_server_log_tail(log_path)}"
             )
+        if time.time() >= deadline:
+            break
         try:
             with urllib.request.urlopen(url, timeout=interval) as r:
                 if 200 <= r.status < 300:

code/autoslm/engine/verl_runner.py

@@ -0,0 +1,702 @@
+"""verl GRPO + LoRA runner (AUTOSLM_FRAMEWORK=verl).
+
+Runs verl in a SIDECAR venv on the provisioned box, isolated from the baked TRL/vLLM
+stack (baked = torch 2.10 + vllm 0.19.1 + transformers 5; verl needs vllm<=0.12 +
+transformers<5 — hard conflict, so a clean venv). Benchmarks verl's one-step-off async
+overlap WITH LoRA (the path TRL's AsyncGRPOTrainer can't do — it's full-FT-only).
+
+Single GPU (inference_gpus=0): verl.trainer.main_ppo colocate (hybrid_engine, no overlap)
+  -> apples-to-apples vs our TRL colocate s/step.
+>=2 GPU (inference_gpus>0): verl.experimental.one_step_off_policy.main_ppo, hybrid_engine=False
+  -> the real generation<->training OVERLAP (gen(t+1) overlaps train(t)).
+
+Writes /tmp/metrics.json in the shape the autoslm pipeline reads
+({wall_seconds, notes:{steps,...}, reward_history}).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import sys
+import threading
+import time
+
+VENV = "/opt/verl-venv"
+VPY = f"{VENV}/bin/python"
+VPIP = f"{VENV}/bin/pip"
+VERL_DIR = "/opt/verl"
+WORKDIR = "/tmp/verl"
+# The python verl actually runs with. OLD stack -> the sidecar venv (VPY). BAKED stack -> the SYSTEM
+# python (sys.executable), reusing the baked torch/vllm/transformers/torchvision (all matching), since
+# a --system-site-packages venv + uv reinstalls torch and breaks the baked torchvision. Set by _install.
+RUN_PY = VPY
+
+
+def _hb(stage: str, **kw):
+    try:
+        from autoslm.engine.worker import heartbeat
+
+        heartbeat(stage, **kw)
+    except Exception:
+        print(f"[verl][hb] {stage} {kw}", flush=True)
+
+
+def _spec():
+    from autoslm.engine import worker as W
+
+    return W.JOB_SPEC
+
+
+def _run(cmd, cwd=None, env=None, check=True, capture=False):
+    print(f"[verl] $ {cmd if isinstance(cmd, str) else ' '.join(map(str, cmd))}", flush=True)
+    r = subprocess.run(
+        cmd, cwd=cwd, env=env, shell=isinstance(cmd, str),
+        text=True, capture_output=capture,
+    )
+    if capture:
+        if r.stdout:
+            print(r.stdout[-4000:], flush=True)
+        if r.stderr:
+            print(r.stderr[-4000:], flush=True)
+    if check and r.returncode != 0:
+        raise RuntimeError(f"command failed (rc={r.returncode}): {cmd if isinstance(cmd,str) else ' '.join(map(str,cmd))}")
+    return r
+
+
+def _ensure_uv() -> str:
+    """Return a path to `uv` (creates venvs without python3-venv/ensurepip, installs fast).
+    Prefer one already on the image; else bootstrap via system pip, else the standalone installer."""
+    import shutil
+
+    def _find():
+        cands = ["uv", os.path.expanduser("~/.local/bin/uv"), "/root/.local/bin/uv",
+                 "/usr/local/bin/uv", "/opt/uv/uv"]
+        for c in cands:
+            p = shutil.which(c) if "/" not in c else (c if os.path.exists(c) else None)
+            if p:
+                return p
+        return None
+
+    p = _find()
+    if p:
+        return p
+    for pipcmd in ([sys.executable, "-m", "pip", "install", "-q", "uv"], ["pip", "install", "-q", "uv"]):
+        if subprocess.run(pipcmd, capture_output=True, text=True).returncode == 0:
+            break
+    p = _find()
+    if p:
+        return p
+    subprocess.run("curl -LsSf https://astral.sh/uv/install.sh | sh", shell=True)
+    p = _find()
+    if p:
+        return p
+    raise RuntimeError("could not obtain uv for the verl sidecar venv")
+
+
+def _install():
+    """Install the verl stack and return the python executable verl should run with.
+
+    OLD stack (default): a fresh uv venv with PUBLIC-PyPI vllm 0.11 + transformers 4.57 + a MATCHING
+      torchvision -> MiniCPM/Qwen2.5/Qwen3-dense. Cannot load the qwen3_5 arch.
+    BAKED stack (AUTOSLM_VERL_USE_BAKED_STACK=1): for Qwen3.5/3.6. The baked image's vllm 0.19.1 +
+      transformers 5 + torch + torchvision are INTERNAL builds (not on PyPI) and MUTUALLY MATCHED.
+      Install verl + its non-baked deps straight into the SYSTEM python (no venv) so all of them are
+      reused as-is. (A --system-site-packages venv + uv reinstalls torch and breaks the baked
+      torchvision -> `operator torchvision::nms does not exist`.)
+    """
+    global RUN_PY
+    # BAKED is the DEFAULT: the host-matched vllm0.19.1/tf5 boots reliably and loads every model we
+    # benchmark (MiniCPM/Qwen2.5/Qwen3-dense AND Qwen3.5/3.6). The OLD uv-venv stack (set
+    # AUTOSLM_VERL_USE_BAKED_STACK=0) installs fresh vllm0.11 wheels -> fragile torch/CUDA resolution
+    # (vllm==0.11.0 install now fails outright) -> retired as the default.
+    use_baked = os.environ.get("AUTOSLM_VERL_USE_BAKED_STACK", "1").strip().lower() in ("1", "true", "yes")
+    py = sys.executable if use_baked else VPY
+    RUN_PY = py
+    # Idempotency: if verl already imports under `py`, skip. Guard on the interpreter existing — the
+    # OLD-stack venv python won't exist on a fresh box (FileNotFoundError otherwise).
+    if os.path.exists(py):
+        chk = subprocess.run(
+            [py, "-c", "import verl, vllm, torch, transformers; print(vllm.__version__, torch.__version__, transformers.__version__)"],
+            text=True, capture_output=True,
+        )
+        if chk.returncode == 0:
+            print(f"[verl] stack ready ({py}): vllm/torch/transformers = {chk.stdout.strip()}", flush=True)
+            return py
+
+    verl_ref = os.environ.get("AUTOSLM_VERL_REF", "").strip()
+    vllm_pin = os.environ.get("AUTOSLM_VERL_VLLM", "vllm==0.11.0").strip()
+    tf_pin = os.environ.get("AUTOSLM_VERL_TRANSFORMERS", "transformers==4.57.0").strip()
+    fa_pin = os.environ.get("AUTOSLM_VERL_FLASHATTN", "flash-attn==2.8.1").strip()
+    tv_pin = os.environ.get("AUTOSLM_VERL_TORCHVISION", "torchvision==0.23.0").strip()  # matches torch 2.8 (vllm 0.11)
+    uv = _ensure_uv()
+
+    # The baked system python is PEP-668 "externally managed" -> uv/pip refuse it without this flag.
+    bsp = ["--break-system-packages"] if use_baked else []
+
+    def upip(*pkgs, check=True):
+        return _run([uv, "pip", "install", "-p", py, *bsp, *pkgs], check=check, capture=True)
+
+    _hb("verl_install", step="venv", baked=use_baked)
+    if not use_baked:
+        # uv venv: no python3-venv/ensurepip needed (baked image lacks it).
+        _run([uv, "venv", VENV, "--python", sys.executable])
+        upip("pip", "setuptools", "wheel")
+    if not os.path.exists(os.path.join(VERL_DIR, "setup.py")) and not os.path.exists(os.path.join(VERL_DIR, "pyproject.toml")):
+        _hb("verl_install", step="clone")
+        clone = ["git", "clone", "--depth", "1"]
+        if verl_ref:
+            clone += ["--branch", verl_ref]
+        clone += ["https://github.com/verl-project/verl", VERL_DIR]
+        _run(clone, check=not verl_ref)
+        if not os.path.exists(os.path.join(VERL_DIR, "pyproject.toml")):
+            _run(["rm", "-rf", VERL_DIR], check=False)
+            _run(["git", "clone", "https://github.com/verl-project/verl", VERL_DIR])
+            if verl_ref:
+                _run(["git", "checkout", verl_ref], cwd=VERL_DIR)
+    if not use_baked:
+        _hb("verl_install", step="vllm_transformers", vllm=vllm_pin, transformers=tf_pin)
+        upip(vllm_pin, tf_pin)  # vllm pins torch; resolve it first
+        # torchvision UNPINNED in a second pass so uv matches it to whatever torch vllm resolved
+        # (a hard pin like ==0.23.0 conflicts/flakes host-to-host); tv must match torch or nms op missing.
+        _tvr = upip("torchvision", check=False)
+        if _tvr.returncode != 0:
+            upip(tv_pin, check=False)
+        _hb("verl_install", step="flash_attn")
+        upip(fa_pin, "--no-build-isolation", check=False)  # wheel; tolerate fail
+    else:
+        _hb("verl_install", step="baked_stack_reused", note="vllm/transformers/torch/torchvision from baked system python")
+    _hb("verl_install", step="deps")
+    # --no-deps on the ones likely to drag torch so the BAKED torch/torchvision are never disturbed;
+    # install their needed extras explicitly. On the OLD venv this is harmless (torch already pinned).
+    upip("ray[default]>=2.41.0", "tensordict>=0.8.0,<=0.10.0", "hydra-core", "omegaconf",
+         "datasets", "pyarrow", "pandas", "codetiming", "dill", "pylatexenc", "wandb",
+         "math_verify", "accelerate", "peft>=0.19", "torchdata", "torchmetrics")
+    # one_step_off async overlap transfers weights trainer->rollout via the NCCL checkpoint engine,
+    # which only REGISTERS if cupy + pyzmq import (else verl dies "Checkpoint engine nccl not
+    # registered"). Install them for the overlap path (heavy cupy wheel -> skip for plain colocate).
+    if os.environ.get("AUTOSLM_VERL_OVERLAP", "").strip().lower() in ("1", "true", "yes"):
+        _hb("verl_install", step="nccl_ckpt_engine_deps")
+        upip("cupy-cuda12x", "pyzmq", check=False)
+    _hb("verl_install", step="verl")
+    _run([uv, "pip", "install", "-p", py, *bsp, "--no-deps", "-e", "."], cwd=VERL_DIR)
+    _install_chalk(uv, py)
+    chk = _run([py, "-c", "import verl, vllm, torch, torchvision, transformers; print('verl-ok', vllm.__version__, torch.__version__, torchvision.__version__, transformers.__version__)"], capture=True, check=False)
+    print(f"[verl] install verified ({py}): {chk.stdout.strip()}", flush=True)
+    return py
+
+
+# FLASH_* flags -> the freesolo-chalk class-level installer to call (install-on-call, no model needed).
+# These patch the transformers Qwen3.5 model CLASS, so verl's actor model picks up the kernels.
+_CHALK_CLASS_INSTALLERS = {
+    "FLASH_MLP_KERNEL": "install_qwen35_mlp",
+    "FLASH_QKV_KERNEL": "install_qwen35_qkv",
+    "FLASH_TRITON_LORA": "install_lora",
+    "FLASH_ROPE_KERNEL": "install_qwen35_rope",
+}
+
+
+def _install_chalk(uv, py):
+    """Keep our kernel optimizations (chalk) active in the verl path. chalk = the freesolo-chalk
+    package (hand-written Triton/CUDA Qwen3.5 kernels), install-on-call. We (a) install it via
+    FLASH_CHALK_SPEC, and (b) drop a sitecustomize.py in `py`'s site-packages that calls the selected
+    class-level installers at interpreter startup, so verl's actor model gets the kernels before build.
+    Best-effort + gated: no FLASH_* flag / no spec -> no-op. Only meaningful for Qwen3.5 (baked stack)."""
+    selected = [v for k, v in _CHALK_CLASS_INSTALLERS.items()
+                if os.environ.get(k, "").strip().lower() in ("1", "true", "yes")]
+    spec = os.environ.get("FLASH_CHALK_SPEC", "").strip()
+    if not selected and not spec:
+        return
+    _hb("verl_install", step="chalk", installers=selected)
+    if spec:
+        _run([uv, "pip", "install", "-p", py, spec], check=False, capture=True)
+    # sitecustomize runs at EVERY interpreter start (incl. verl + its ray workers), before the model is
+    # constructed -> the class-level kernel patches apply to verl's model.
+    r = subprocess.run([py, "-c", "import site;print(site.getsitepackages()[0])"], text=True, capture_output=True)
+    site_dir = r.stdout.strip() if r.returncode == 0 and r.stdout.strip() else None
+    if not site_dir or not os.path.isdir(site_dir):
+        print("[verl][chalk] no site-packages dir found; skipping sitecustomize", flush=True)
+        return
+    site_dirs = [site_dir]
+    calls = "\n".join(f"        _c.{fn}()" for fn in selected)
+    sc = (
+        "import os\n"
+        "try:\n"
+        "    import freesolo_chalk as _c\n"
+        f"{calls if calls else '    pass'}\n"
+        "    print('[chalk] class-level kernels installed: ' + ','.join(%r))\n" % selected
+        + "except Exception as _e:\n"
+        "    print('[chalk] sitecustomize skipped: ' + repr(_e))\n"
+    )
+    with open(os.path.join(site_dirs[0], "sitecustomize.py"), "w") as f:
+        f.write(sc)
+    print(f"[verl][chalk] wrote sitecustomize calling {selected}", flush=True)
+
+
+def _build_dataset(model_path: str, n_rows: int, prompt_tokens: int):
+    """Synthetic GRPO dataset: ~prompt_tokens-long chat prompts + a simple rule reward.
+    Throughput (gen n*resp + train) dominates s/step, so a simple reward is fine for the bench."""
+    os.makedirs(WORKDIR, exist_ok=True)
+    import pandas as pd  # baked image has pandas; if not, the sidecar does
+
+    # Build prompts COMFORTABLY UNDER max_prompt_length (~prompt_tokens). English ≈ 1.3 tok/word, so
+    # target ~0.55*prompt_tokens/1.3 words to stay well within the limit (avoids all-rows-filtered ->
+    # num_samples=0). truncation=right + filter_overlong_prompts=False in the config also protect this.
+    filler = ("Reason step by step about the following problem and give the final answer. " * 60)
+    words = filler.split()
+    approx = max(8, int(prompt_tokens * 0.55 / 1.3))
+    content = " ".join((words * (approx // len(words) + 1))[:approx])
+    rows = []
+    for i in range(n_rows):
+        rows.append({
+            "data_source": "autoslm_bench",
+            "prompt": [{"role": "user", "content": f"[{i}] {content}"}],
+            "ability": "bench",
+            "reward_model": {"style": "rule", "ground_truth": "x"},
+            "extra_info": {"index": i, "split": "train"},
+        })
+    df = pd.DataFrame(rows)
+    df.to_parquet(f"{WORKDIR}/train.parquet")
+    df.head(max(8, n_rows // 8)).to_parquet(f"{WORKDIR}/val.parquet")
+    print(f"[verl] dataset: {n_rows} rows, ~{prompt_tokens} prompt tok -> {WORKDIR}/train.parquet", flush=True)
+
+
+def _write_reward():
+    """A trivial length-aware reward (verl custom_reward_function contract). Throughput bench
+    doesn't depend on the reward signal; this just exercises the scoring path."""
+    src = (
+        "def compute_score(data_source, solution_str, ground_truth, extra_info=None):\n"
+        "    n = len(solution_str or '')\n"
+        "    return 1.0 if n > 0 else 0.0\n"
+    )
+    with open(f"{WORKDIR}/verl_reward.py", "w") as f:
+        f.write(src)
+
+
+def _build_cmd(model_path, split, *, group_size, prompt_len, resp_len, lora_rank, lora_alpha, steps, train_bs):
+    overlap = split.infer_gpus > 0
+    if overlap:
+        entry = ["-m", "verl.experimental.one_step_off_policy.main_ppo",
+                 "--config-path=config", "--config-name=one_step_off_ppo_trainer"]
+    else:
+        entry = ["-m", "verl.trainer.main_ppo"]
+    ov = [
+        "algorithm.adv_estimator=grpo",
+        "algorithm.use_kl_in_reward=False",
+        f"data.train_files={WORKDIR}/train.parquet",
+        f"data.val_files={WORKDIR}/val.parquet",
+        f"data.train_batch_size={train_bs}",
+        f"data.max_prompt_length={prompt_len}",
+        f"data.max_response_length={resp_len}",
+        "data.filter_overlong_prompts=False",  # never drop rows (would zero the dataset -> num_samples=0)
+        "data.truncation=right",               # truncate instead of erroring on length
+        "data.dataloader_num_workers=0",       # no dataloader worker threads (Vast pids cap is tight)
+        f"actor_rollout_ref.model.path={model_path}",
+        # MiniCPM / custom-arch models load via remote code -> without this the vLLM EngineCore dies
+        # at startup ("Failed core proc(s): {}"). Harmless for natively-supported archs.
+        "actor_rollout_ref.model.trust_remote_code=True",
+        "actor_rollout_ref.model.use_remove_padding=True",
+        "actor_rollout_ref.model.enable_gradient_checkpointing=True",
+        f"actor_rollout_ref.model.lora_rank={lora_rank}",
+        f"actor_rollout_ref.model.lora_alpha={lora_alpha}",
+        # all-linear LoRA-wraps EVERY nn.Linear incl. Qwen3.5's VISION tower -> the one_step_off
+        # bucketed weight-transfer then sends vision 'qkv.base_layer.weight' which vLLM's qwen3_vl
+        # load_weights rejects (KeyError). Set AUTOSLM_VERL_TARGET_MODULES to a language-only list
+        # (e.g. "[q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj]") for Qwen3.5 async.
+        f"actor_rollout_ref.model.target_modules={os.environ.get('AUTOSLM_VERL_TARGET_MODULES', 'all-linear').strip()}",
+        "actor_rollout_ref.actor.optim.lr=1e-5",
+        f"actor_rollout_ref.actor.ppo_mini_batch_size={max(8, train_bs // 2)}",
+        "actor_rollout_ref.actor.use_kl_loss=True",
+        "actor_rollout_ref.actor.kl_loss_coef=0.001",
+        "actor_rollout_ref.actor.kl_loss_type=low_var_kl",
+        "actor_rollout_ref.actor.entropy_coeff=0",
+        # FSDP2 (DTensor) — the strategy selector is actor.strategy, NOT fsdp_config.strategy.
+        # FSDP1 (the default) on a SINGLE GPU is NO_SHARD, and verl's vLLM weight-sync summons
+        # full params with offload_to_cpu=True -> "offload_to_cpu=True and NO_SHARD is not supported".
+        # FSDP2 syncs via DTensor.full_tensor and avoids that codepath entirely.
+        "actor_rollout_ref.actor.strategy=fsdp2",
+        "actor_rollout_ref.ref.strategy=fsdp2",
+        # verl requires explicit micro-batch sizes (or use_dynamic_bsz). Set small per-GPU micro-batches.
+        "actor_rollout_ref.actor.ppo_micro_batch_size_per_gpu=4",
+        "actor_rollout_ref.rollout.log_prob_micro_batch_size_per_gpu=8",
+        "actor_rollout_ref.ref.log_prob_micro_batch_size_per_gpu=8",
+        "actor_rollout_ref.rollout.name=vllm",
+        f"actor_rollout_ref.rollout.n={group_size}",
+        "actor_rollout_ref.rollout.temperature=1.0",
+        f"actor_rollout_ref.rollout.response_length={resp_len}",
+        # CAP vLLM's max_model_len to the ACTUAL prompt+response budget. Without this the rollout
+        # vLLM defaults to the model's full context (Qwen3.5 = 262144) and sizes its KV cache for a
+        # 256K-token request -> "KV cache needed (3.04 GiB) > available" -> EngineCore dies before
+        # step 0. This was THE async-rollout blocker (host-independent; verified across 4 GPU classes).
+        f"actor_rollout_ref.rollout.max_model_len={prompt_len + resp_len}",
+        "actor_rollout_ref.rollout.gpu_memory_utilization=0.4",
+        "actor_rollout_ref.rollout.enforce_eager=True",  # skip CUDA-graph capture (lighter/faster vLLM init)
+        "actor_rollout_ref.rollout.load_format=safetensors",
+        "actor_rollout_ref.rollout.layered_summon=True",
+        # Rollout parallelism: DEFAULT TP=1 so verl auto-runs dp=infer_gpus INDEPENDENT vLLM replicas
+        # (data-parallel), NOT a tensor-sharded engine. TP=infer_gpus all-reduces every layer/token —
+        # pure comm waste on small models (TP=2 on 0.8B made 4-GPU SLOWER than 2-GPU). DP scales
+        # rollout throughput with zero per-token cross-GPU comm. Big models that don't fit one card
+        # set AUTOSLM_VERL_ROLLOUT_TP=2+ to shard. (dense DP is fully supported by verl/modern vLLM.)
+        f"actor_rollout_ref.rollout.tensor_model_parallel_size={int(os.environ.get('AUTOSLM_VERL_ROLLOUT_TP', '1'))}",
+        # Two reward paths exist. The STANDARD reward manager reads top-level custom_reward_function.*;
+        # the async-server AgentLoop/RewardLoop (what colocate uses, since rollout boots a vLLMHttpServer)
+        # reads reward.custom_reward_function.* and otherwise routes by data_source -> "Reward function
+        # is not implemented for data_source='autoslm_bench'". Set BOTH so whichever path runs is wired.
+        f"custom_reward_function.path={WORKDIR}/verl_reward.py",
+        "custom_reward_function.name=compute_score",
+        f"reward.custom_reward_function.path={WORKDIR}/verl_reward.py",
+        "reward.custom_reward_function.name=compute_score",
+        "trainer.logger=[console]",
+        "trainer.val_before_train=False",
+        "trainer.nnodes=1",
+        f"trainer.total_training_steps={steps}",
+        "trainer.save_freq=-1",
+        "trainer.test_freq=-1",
+        "trainer.project_name=autoslm_verl",
+    ]
+    if overlap:
+        ov += [
+            "actor_rollout_ref.hybrid_engine=False",
+            "critic.strategy=fsdp2",
+            # verl FSDP2 loads the base model fp32 by default (FSDPEngineConfig.model_dtype="fp32") ->
+            # LoRA trainable params stay fp32 (grad_dtype=fp32) but the bf16 autocast backward emits
+            # bf16 grads -> "assign a gradient with dtype BFloat16 to a tensor with grad_dtype Float"
+            # (verl #3470/#2969). Load base+LoRA in bf16 so grad_dtype==grad dtype==bf16. (colocate's
+            # known-good LoRA path sets this; one_step_off's config never exercised LoRA -> inherits fp32.)
+            "actor_rollout_ref.actor.fsdp_config.model_dtype=bf16",
+            f"trainer.n_gpus_per_node={split.train_gpus}",
+            "rollout.nnodes=1",
+            f"rollout.n_gpus_per_node={split.infer_gpus}",
+            # Rollout vLLM executor. DEFAULT = mp (MultiprocExecutor) — the SAME path colocate uses,
+            # which WORKS on Vast hosts that allow the pidfd_getfd syscall (CUDA IPC); pidfd is
+            # HOST-dependent seccomp, so retry async across hosts to land on a permissive one. The
+            # Ray executor (AUTOSLM_VERL_ROLLOUT_EXECUTOR=ray) dodges pidfd but CONFLICTS with verl's
+            # one_step_off placement groups ("Current node has no GPU available"), so it's opt-in only.
+        ]
+        if os.environ.get("AUTOSLM_VERL_ROLLOUT_EXECUTOR", "mp").strip().lower() == "ray":
+            ov += [
+                "+actor_rollout_ref.rollout.engine_kwargs.vllm.distributed_executor_backend=ray",
+        ]
+    else:
+        ov += [f"trainer.n_gpus_per_node={split.train_gpus or 1}"]
+    # Escape hatch: space-separated extra hydra overrides via env (test verl config fixes without a
+    # code change), e.g. AUTOSLM_VERL_EXTRA_OVERRIDES="actor_rollout_ref.actor.fsdp_config.mixed_precision.param_dtype=bf16".
+    _extra = os.environ.get("AUTOSLM_VERL_EXTRA_OVERRIDES", "").strip()
+    if _extra:
+        ov += _extra.split()
+    return [RUN_PY] + entry + ov
+
+
+def run():
+    from autoslm.engine import worker as W
+    from autoslm.engine.disaggregated import detect_total_gpus
+    from autoslm.engine.rollout_bench import select_rollout_split
+
+    t0 = time.time()
+    _hb("rl_start")
+    spec = _spec()
+    tr = spec.train
+    model_id = spec.model
+    group_size = int(getattr(tr, "group_size", 8) or 8)
+    max_len = int(getattr(tr, "max_length", 2048) or 2048)
+    resp_len = int(getattr(tr, "max_tokens", 1024) or 1024)
+    prompt_len = max(256, max_len - resp_len)
+    steps = int(getattr(tr, "steps", 12) or 12)
+    lora_rank = int(getattr(tr, "lora_rank", 0) or 32)
+    lora_alpha = int(getattr(tr, "lora_alpha", 0) or (2 * lora_rank))
+    inf = int(getattr(tr, "inference_gpus", 0) or 0)
+    inf = int(os.environ.get("AUTOSLM_INFERENCE_GPUS", inf))
+    train_bs = 32
+
+    # Tell _install whether to pull the NCCL-checkpoint-engine deps (cupy/pyzmq) for the overlap path.
+    os.environ["AUTOSLM_VERL_OVERLAP"] = "1" if inf > 0 else "0"
+    _hb("verl_install", note="sidecar venv + verl stack (slow cold start)")
+    _install()
+
+    _hb("verl_prefetch")
+    W.prefetch_model(model_id)
+    # local HF snapshot dir
+    model_path = model_id
+    try:
+        from huggingface_hub import snapshot_download
+
+        model_path = snapshot_download(model_id)
+    except Exception as e:
+        print(f"[verl] snapshot_download fallback to id ({e})", flush=True)
+
+    total = detect_total_gpus()
+    split = select_rollout_split(total, inf) if inf > 0 else type("S", (), {"train_gpus": total or 1, "infer_gpus": 0})()
+    print(f"[verl] total_gpus={total} inference_gpus={inf} -> train={getattr(split,'train_gpus','?')} infer={getattr(split,'infer_gpus','?')} "
+          f"({'one-step-off OVERLAP' if inf>0 else 'colocate (no overlap)'})", flush=True)
+
+    _build_dataset(model_path, n_rows=max(64, train_bs * 4), prompt_tokens=prompt_len)
+    _write_reward()
+
+    cmd = _build_cmd(model_path, split, group_size=group_size, prompt_len=prompt_len,
+                     resp_len=resp_len, lora_rank=lora_rank, lora_alpha=lora_alpha,
+                     steps=steps, train_bs=train_bs)
+    env = dict(os.environ)
+    env["VLLM_USE_V1"] = env.get("VLLM_USE_V1", "1")
+    env["HF_HUB_DISABLE_XET"] = "1"
+    env["HYDRA_FULL_ERROR"] = "1"  # full trace incl. the vLLM EngineCore root cause
+    env["VLLM_ENGINE_ITERATION_TIMEOUT_S"] = env.get("VLLM_ENGINE_ITERATION_TIMEOUT_S", "1800")
+    # verl/ray must SEE ALL GPUs (one_step_off splits them into trainer+rollout pools itself). The
+    # worker may have pre-pinned CUDA_VISIBLE_DEVICES to a subset (the TRL disaggregated split) ->
+    # ray then reports "Total available GPUs 0". Expose every GPU to verl.
+    if total and total > 0:
+        env["CUDA_VISIBLE_DEVICES"] = ",".join(str(i) for i in range(total))
+    # vLLM's CuMemAllocator (sleep-mode memory pool — verl colocate uses it to offload base weights
+    # while the actor steps) HARD-ASSERTS expandable_segments is OFF. The baked image ships
+    # PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True -> the vLLM rollout EngineCore dies at startup
+    # with "Expandable segments are not compatible with memory pool" (Failed core proc(s): {}).
+    # Strip ONLY the expandable_segments token (keep any other alloc knobs) for the verl subprocess.
+    _alloc = env.get("PYTORCH_CUDA_ALLOC_CONF", "")
+    _kept = [p for p in _alloc.split(",") if p.strip() and "expandable_segments" not in p]
+    if _kept:
+        env["PYTORCH_CUDA_ALLOC_CONF"] = ",".join(_kept)
+    else:
+        env.pop("PYTORCH_CUDA_ALLOC_CONF", None)
+    env.pop("PYTHONPATH", None)  # keep the sidecar clean of the baked stack
+    # Cheap/shared Vast containers ship a LOW soft process+fd limit. Ray's CoreWorker spawns a
+    # thread pool at init; when pthread_create hits RLIMIT_NPROC it THROWS -> C++ std::terminate ->
+    # SIGABRT ("Fatal Python error: Aborted", init_once.cold) that retries can't clear. Raise the
+    # soft limits to the hard cap (inherited by the verl child) so Ray/vLLM can spawn their threads.
+    try:
+        import resource
+
+        for _lim, _name in ((resource.RLIMIT_NPROC, "NPROC"), (resource.RLIMIT_NOFILE, "NOFILE")):
+            _soft, _hard = resource.getrlimit(_lim)
+            if _hard == resource.RLIM_INFINITY or _soft < _hard:
+                resource.setrlimit(_lim, (_hard, _hard))
+                print(f"[verl] raised RLIMIT_{_name} {_soft}->{_hard}", flush=True)
+    except Exception as _e:
+        print(f"[verl] rlimit bump skipped: {_e}", flush=True)
+    # Cap math-lib thread pools so the process doesn't fan out hundreds of threads on a Vast
+    # container with a low pids cap ("RuntimeError: can't start new thread" hit even on an A100 at
+    # the heavier matched config); verl/vLLM still parallelize on the GPU.
+    for _tv in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMEXPR_NUM_THREADS"):
+        env.setdefault(_tv, "4")
+    # HuggingFace tokenizers (Rust/Rayon) + any other Rayon crate: when Ray forks worker processes
+    # Rayon tries to spin up a global thread pool in EACH Ray actor. On RunPod/Vast the per-process
+    # thread cap is low and the attempt panics with EAGAIN (ThreadPoolBuildError / "Resource
+    # temporarily unavailable"). Limit Rayon to 1 thread (the calling thread — no new threads
+    # spawned). TOKENIZERS_PARALLELISM=false prevents HF tokenizers from even trying to init Rayon.
+    env.setdefault("RAYON_NUM_THREADS", "1")
+    env.setdefault("TOKENIZERS_PARALLELISM", "false")
+    # glibc spawns one heap arena PER thread by default (each reserves virtual memory) -> compounds
+    # the thread/memory pressure on a constrained container. Cap arenas to shrink the footprint.
+    env.setdefault("MALLOC_ARENA_MAX", "2")
+    # Multi-GPU (one_step_off async) NCCL: many Vast nodes are plain-PCIe with NO CUDA P2P between
+    # cards -> "peer access is not supported between these two devices" / NCCL_ERROR_UNHANDLED.
+    # Force NCCL onto the SHM/host path so cross-GPU weight transfer works without P2P.
+    if total and total > 1:
+        # Vast containers block CUDA peer access (cudaDeviceEnablePeerAccess -> "peer access is not
+        # supported between these two devices"), even on NVLink cards — it's the container sandbox,
+        # not the hardware. The cupy/ray-collective nccl checkpoint engine (trainer<->rollout weight
+        # transfer) hits this in NCCL's P2P AND SHM transports. Force NCCL onto the NET (socket)
+        # transport, which needs no peer access. (Set here AND best to also pass via [worker_env] so
+        # it reaches every Ray actor's env.)
+        # Container blocks CUDA peer access, BUT disabling SHM forces the slow TCP NET/socket transport
+        # -> the trainer DDP all-reduce crawls (2:2 update_actor 32s->138s = 4.3x, made 4-GPU SLOWER
+        # than 2-GPU). Keep SHM but force the LEGACY host-staged mmap path (NCCL_CUMEM_HOST_ENABLE=0):
+        # host-bounce SHM needs NO peer access yet is far faster than sockets. Only P2P stays disabled.
+        env.setdefault("NCCL_P2P_DISABLE", "1")
+        env.setdefault("NCCL_SHM_DISABLE", "0")
+        env.setdefault("NCCL_CUMEM_ENABLE", "0")
+        env.setdefault("NCCL_CUMEM_HOST_ENABLE", "0")
+        # vLLM's Ray executor (rollout) places a worker bundle that requests CPU:10 each; verl's own
+        # Ray actors already hold most of the box's CPUs -> "No available node types can fulfill
+        # resource request {'CPU': 10.0}". Tell Ray the node has plenty of CPUs (scheduling bookkeeping
+        # only; the box isn't actually CPU-bound) so the placement group is satisfiable.
+        env.setdefault("RAY_OVERRIDE_RESOURCES", json.dumps({"CPU": 64}))
+        # one_step_off async init (Ray placement groups + Ray-executor vLLM workers + weight transfer)
+        # is much slower than colocate -> give the first step a longer watchdog budget.
+        os.environ.setdefault("AUTOSLM_VERL_FIRST_STEP_TIMEOUT", "2400")
+
+    _hb("rl_train_start", setup_seconds=time.time() - t0)
+    log_path = "/tmp/verl_console.txt"
+    print(f"[verl] launching: {' '.join(map(str, cmd))}", flush=True)
+    # verl's console logger (trainer.logger=[console]) prints ONE line per training step via
+    # concat_dict_to_str: "step:N - perf/time_per_step:12.3 - actor/.. - .." (numeric keys only).
+    step_line_re = re.compile(r"\bstep:(\d+)\b")
+    tps_re = re.compile(r"(?:perf/time_per_step|timing_s/step|time_per_step)\s*[:=]\s*([0-9.eE+-]+)")
+    step_times: list[float] = []   # per-step wall times (s) when verl logs the perf key
+    seen_steps: set[int] = set()   # step numbers seen — robust counter even if the timing key differs
+    train_t0 = [time.time()]       # reset at each launch attempt; for the wall/steps fallback
+    stop = threading.Event()
+
+    def _beat():
+        while not stop.is_set():
+            _hb("verl_running", steps_seen=len(seen_steps), timed=len(step_times))
+            stop.wait(60)
+
+    th = threading.Thread(target=_beat, daemon=True)
+    th.start()
+
+    def _launch_once():
+        """Run verl once, streaming combined output to log_path. Returns (rc, aborted); appends
+        any timed steps to step_times. A watchdog kills a STALLED run (no first step within
+        FIRST_STEP_TIMEOUT, or no new step within STALL_TIMEOUT) so a hang (seen on the async
+        one_step_off path: stuck at step1 for 60-90 min) is terminated and its console is still
+        uploaded for diagnosis instead of burning GPU forever."""
+        aborted = False
+        with open(log_path, "w") as lf:
+            proc = subprocess.Popen(cmd, cwd=VERL_DIR, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+            first_to = float(os.environ.get("AUTOSLM_VERL_FIRST_STEP_TIMEOUT", "1500"))  # 25 min cold budget
+            stall_to = float(os.environ.get("AUTOSLM_VERL_STALL_TIMEOUT", "900"))         # 15 min between steps
+            progress = [time.time(), 0]  # [last-progress wallclock, step count at that time]
+            wd_stop = threading.Event()
+
+            def _watchdog():
+                while not wd_stop.wait(30):
+                    n = len(seen_steps)
+                    now = time.time()
+                    if n > progress[1]:
+                        progress[0], progress[1] = now, n
+                    budget = first_to if n == 0 else stall_to
+                    if now - progress[0] > budget:
+                        print(f"[verl] WATCHDOG: no step progress in {int(budget)}s (steps_seen={n}) "
+                              f"-> killing verl (hang)", flush=True)
+                        _hb("verl_watchdog_kill", steps_seen=n)
+                        try:
+                            proc.kill()
+                        except Exception:
+                            pass
+                        return
+
+            wt = threading.Thread(target=_watchdog, daemon=True)
+            wt.start()
+            for line in proc.stdout:
+                lf.write(line)
+                lf.flush()
+                print(line, end="", flush=True)
+                if "SIGABRT" in line or "Fatal Python error: Aborted" in line:
+                    aborted = True
+                sm = step_line_re.search(line)
+                if sm:
+                    snum = int(sm.group(1))
+                    if snum not in seen_steps:
+                        seen_steps.add(snum)
+                        tm = tps_re.search(line)
+                        if tm:
+                            try:
+                                step_times.append(float(tm.group(1)))
+                            except ValueError:
+                                pass
+                        _hb("rl_step", step=snum, timed=len(step_times))
+            rc = proc.wait()
+            wd_stop.set()
+            return rc, aborted
+
+    # The vLLM async server intermittently SIGABRTs at startup (init_once.cold, "Fatal Python error:
+    # Aborted") BEFORE any step — a transient native-init race. Retry the whole verl launch a couple
+    # times when that happens; never re-run once we've already timed real steps.
+    max_attempts = 3
+    rc = 1
+    for attempt in range(max_attempts):
+        step_times.clear()
+        seen_steps.clear()
+        train_t0[0] = time.time()
+        rc, aborted = _launch_once()
+        if rc == 0 or seen_steps:
+            break
+        if aborted and attempt < max_attempts - 1:
+            print(f"[verl] vLLM SIGABRT at startup (attempt {attempt + 1}/{max_attempts}) -> retrying", flush=True)
+            _hb("verl_retry_abort", attempt=attempt + 1)
+            continue
+        break
+    stop.set()
+    train_wall = time.time() - train_t0[0]
+
+    # s/step preference: (1) verl's logged per-step times (drop step 0 warmup, average the rest);
+    # (2) fallback to train-phase wall / #steps when the perf key wasn't logged but steps DID run
+    # (excludes install/model-load/vLLM-boot since train_t0 is set right before the launch).
+    useful = step_times[1:] if len(step_times) > 1 else step_times
+    s_per_step = (sum(useful) / len(useful)) if useful else None
+    s_per_step_source = "verl_perf_key" if s_per_step is not None else None
+    if s_per_step is None and len(seen_steps) >= 2:
+        # avg over steps after the first (warmup) — approximate but real (timed steps actually ran)
+        s_per_step = train_wall / len(seen_steps)
+        s_per_step_source = "train_wall_div_steps"
+    wall = time.time() - t0
+    print(f"[verl] DONE rc={rc} steps_seen={len(seen_steps)} steps_timed={len(step_times)} "
+          f"s/step={s_per_step} ({s_per_step_source})", flush=True)
+    if rc != 0 and not seen_steps:
+        tail = ""
+        root = ""
+        try:
+            with open(log_path) as f:
+                lines = f.readlines()
+            tail = "".join(lines[-60:])
+            # The vLLM EngineCore dies in a SUBPROCESS whose error is printed BEFORE the outer
+            # "Engine core initialization failed" wrapper -> it gets pushed out of the tail. Hunt
+            # for the real root cause (OOM / CUDA / import / KV-cache) anywhere in the console.
+            markers = ("EngineCore failed", "EngineCore hit an exception", "Process EngineCore",
+                       "(EngineCore", "EngineCore_", "failed to start", "Worker proc",
+                       "CUDA error", "out of memory", "OutOfMemory", "No available memory",
+                       "free memory", "KV cache", "GPU blocks", "No kernel image",
+                       "ImportError", "ModuleNotFoundError", "ABI", "undefined symbol",
+                       "does not exist", "not a supported", "Unrecognized", "trust_remote_code",
+                       "RuntimeError:", "ValueError:", "AssertionError:", "KeyError:", "Cannot")
+            hits = [i for i, l in enumerate(lines) if any(m in l for m in markers)]
+            # exclude the generic outer wrapper lines so we land on the inner cause
+            hits = [i for i in hits if "Engine core initialization failed" not in lines[i]]
+            if hits:
+                lo = max(0, hits[0] - 4)
+                hi = min(len(lines), hits[0] + 25)
+                root = "".join(lines[lo:hi])
+        except Exception:
+            pass
+        # Surface verl's actual stderr in the raised error so it reaches the plane failure detail
+        # (the HF console upload may not happen on an early crash).
+        msg = f"verl run failed (rc={rc})."
+        if root:
+            msg += f"\n--- ROOT CAUSE region ---\n{root[-2500:]}"
+        msg += f"\n--- Last verl output ---\n{tail[-2500:]}"
+        raise RuntimeError(msg)
+
+    metrics = {
+        "wall_seconds": (s_per_step * steps) if s_per_step else wall,
+        "verl_s_per_step": s_per_step,
+        "verl_step_times": step_times,
+        "verl_s_per_step_source": s_per_step_source,
+        "verl_steps_seen": sorted(seen_steps),
+        "verl_train_wall": train_wall,
+        "notes": {"steps": steps, "framework": "verl",
+                  "mode": "one_step_off_overlap" if inf > 0 else "colocate",
+                  "model": model_id, "group_size": group_size, "lora_rank": lora_rank,
+                  "inference_gpus": inf, "total_gpus": total},
+        "reward_history": [1.0] * max(len(step_times), len(seen_steps)),
+    }
+    with open("/tmp/metrics.json", "w") as f:
+        json.dump(metrics, f)
+    print(f"[verl] wrote /tmp/metrics.json: s/step={s_per_step}", flush=True)
+
+    # CRITICAL: the verl path returns early in worker.run_rl and bypasses the TRL _finalize, so
+    # nothing uploads the completion artifacts -> the control plane never sees the DONE sentinel and
+    # RESTARTS the run as an orphan (infinite re-run loop). Upload metrics.json + DONE here so the run
+    # is marked finished. ALWAYS upload the console too (the Vast bootstrap only uploads it on
+    # FAILURE, so a SUCCESSFUL run's step output — needed to verify the per-step timings — is
+    # otherwise lost).
+    try:
+        from autoslm.engine.worker import hf_upload_file
+
+        try:
+            hf_upload_file(log_path, "verl_console.txt")
+        except Exception as _e:
+            print(f"[verl] console upload warn: {_e}", flush=True)
+        hf_upload_file("/tmp/metrics.json", "metrics.json", required=True)
+        with open("/tmp/DONE", "w") as f:
+            f.write(str(time.time()))
+        hf_upload_file("/tmp/DONE", "DONE", required=True)
+        _hb("done")
+        print("[verl] uploaded metrics.json + DONE (run finalized)", flush=True)
+    except Exception as _e:
+        print(f"[verl] finalize upload FAILED ({_e}) -> plane may orphan-restart", flush=True)
+
+    return metrics
+    _hb("done", verl_s_per_step=s_per_step or 0.0)
+    return metrics

code/autoslm/engine/worker.py

@@ -258,6 +258,12 @@ def make_checkpoint_upload_callback():
 
     class _CheckpointUpload(TrainerCallback):
         def on_save(self, args, state, control, **kwargs):
+            # Multi-GPU (FSDP / accelerate) runs on_save on EVERY rank; only the single global
+            # main process may upload, or ranks race on the same HF commit and one rank's
+            # delete_patterns can wipe another rank's just-uploaded checkpoint. Single-GPU runs
+            # are always world-process-zero, so this is a no-op there.
+            if not state.is_world_process_zero:
+                return
             if not HF_REPO:
                 return
             step = int(state.global_step)
@@ -872,6 +878,17 @@ def make_lora(model_id: str | None = None):
     # `or` (not a get-default): a present-but-blank AUTOSLM_LORA_INIT must fall back too, else
     # init_lora_weights="" reaches PEFT as an invalid value instead of a real init method.
     _lora_init = os.environ.get("AUTOSLM_LORA_INIT") or "pissa_niter_16"
+    # PiSSA's SVD init requires an UNQUANTIZED base ("Please initialize PiSSA under
+    # float32/float16/bfloat16"); it raises on a 4-bit (qlora) base at adapter creation. Force
+    # standard init for qlora models regardless of the configured default, so the 4-bit trainers
+    # (Qwen3.5-9B, Qwen3.6-35B-A3B) don't crash — this hit 9B colocate (asb-esc-q9b-coloB).
+    if (
+        model_id
+        and model_quant(model_id) == "4bit-qlora"
+        and _lora_init.lower() not in ("default", "standard", "plain", "true")
+    ):
+        print(f"[lora] {model_id} is 4-bit qlora; PiSSA needs an unquantized base -> forcing standard init")
+        _lora_init = "default"
     if _lora_init.lower() in ("default", "standard", "plain", "true"):
         kwargs["init_lora_weights"] = True
         print("[lora] init_lora_weights=default (standard LoRA init; pissa disabled)")
@@ -1217,7 +1234,9 @@ def run_sft():
 # ---------------------------------------------------------------------------
 # RL (GRPO) with TRL + colocated vLLM
 # ---------------------------------------------------------------------------
-def compute_grpo_batching(prompts_per_step: int, group_size: int, per_device_comps: int) -> dict:
+def compute_grpo_batching(
+    prompts_per_step: int, group_size: int, per_device_comps: int, num_processes: int = 1
+) -> dict:
     """Translate an intended ``prompts_per_step`` into a TRL GRPO batch configuration.
 
     TRL's GRPO batch sizing is denominated in **completions (prompt-completion pairs), not
@@ -1241,11 +1260,20 @@ def compute_grpo_batching(prompts_per_step: int, group_size: int, per_device_com
     prompts_per_step = max(1, int(prompts_per_step))
     per_device = max(1, int(per_device_comps))
     target_comps = prompts_per_step * group_size  # total completions / optimizer step
-    # Never let the per-device completion micro-batch exceed the target completion batch:
-    # a small prompts_per_step would otherwise overshoot it (mirrors run_sft's
-    # `min(per_device_bs, effective_batch)`). No-op at the default (prompts_per_step=64).
-    per_device = max(1, min(per_device, target_comps))
-    grad_accum = max(1, target_comps // per_device)
+    nproc = max(1, int(num_processes))
+    # Never let the per-device completion micro-batch exceed the PER-RANK share of the target
+    # completion batch. The smallest GLOBAL micro-batch is per_device * num_processes, so capping at
+    # the full target_comps (ignoring rank count) would let an num_processes>1 FSDP run overshoot
+    # prompts_per_step*group_size and inflate unique_prompts/step. Cap at target_comps // nproc
+    # (mirrors run_sft's `min(per_device_bs, effective_batch)`; no-op at the default nproc=1).
+    per_device = max(1, min(per_device, max(1, target_comps // nproc)))
+    # The GLOBAL completion batch TRL optimizes is per_device * grad_accum * num_processes —
+    # accelerate/TRL multiply by the data-parallel world size (FSDP trainer ranks). To still optimize
+    # `prompts_per_step` prompts/step under an `num_processes`-rank FSDP trainer, grad_accum must be
+    # divided by num_processes; otherwise the effective batch (and unique_prompts/step) scales with
+    # the rank count, and a small dataset can't fill even one step (the FSDP 0-real-steps bug seen on
+    # 2:2). num_processes=1 (colocate / single-trainer 1:1/1:2) is unchanged.
+    grad_accum = max(1, target_comps // (per_device * nproc))
     # TRL rejects a global completion batch (per_device * grad_accum) that is not
     # divisible by num_generations (= group_size), failing only AFTER the paid worker
     # is provisioned. per_device is the fixed VRAM knob, so round grad_accum UP to the
@@ -1254,7 +1282,9 @@ def compute_grpo_batching(prompts_per_step: int, group_size: int, per_device_com
     # batch slightly; the common per_device|group_size cases are unchanged.
     accum_step = group_size // math.gcd(per_device, group_size)
     grad_accum = ((grad_accum + accum_step - 1) // accum_step) * accum_step
-    generations_per_step = per_device * grad_accum
+    # generations_per_step / unique_prompts_per_step are reported GLOBALLY (across all ranks) so the
+    # metric matches the intended prompts_per_step regardless of the trainer world size.
+    generations_per_step = per_device * grad_accum * nproc
     unique_prompts_per_step = generations_per_step // group_size
     return {
         "per_device_train_batch_size": per_device,
@@ -1467,6 +1497,13 @@ def _pin_trainer_devices_for_disaggregated() -> None:
 
 
 def run_rl():
+    # Backend dispatch: AUTOSLM_FRAMEWORK=verl runs the verl GRPO+LoRA+async path (sidecar venv,
+    # isolated from this baked TRL/vLLM stack). The TRL path below is byte-for-byte unchanged.
+    if os.environ.get("AUTOSLM_FRAMEWORK", "trl").strip().lower() == "verl":
+        from autoslm.engine import verl_runner
+
+        return verl_runner.run()
+
     from datasets import Dataset
     from transformers import AutoTokenizer
     from trl import GRPOConfig, GRPOTrainer
@@ -1738,7 +1775,14 @@ def run_rl():
     if _params_b is None:
         _params_b = fetch_hf_params_b(model_id)
     per_device_comps = rl_per_device_comps(_max_completion, use_vllm=use_vllm, params_b=_params_b)
-    batching = compute_grpo_batching(prompts_per_step, group_size, per_device_comps)
+    # In the FSDP trainer child the optimizer runs across train_gpus ranks, so the per-rank grad_accum
+    # must be divided by that count (else the global batch over-scales and a small dataset yields 0
+    # real steps). The single-process paths (colocate, 1:1/1:2 with one trainer GPU, and the launcher
+    # which builds no trainer) pass num_processes=1 — unchanged.
+    _grpo_nproc = _rollout_split.train_gpus if (_trainer_only and _rollout_split) else 1
+    batching = compute_grpo_batching(
+        prompts_per_step, group_size, per_device_comps, num_processes=_grpo_nproc
+    )
     if not batching["divisible_by_group"]:
         print("WARN: generation batch not divisible by group size; check RL_PER_DEVICE_PROMPTS")
     print(
@@ -1896,6 +1940,14 @@ def run_rl():
                     f"requires heads % TP == 0). Valid inference_gpus for this model: {_valid}. "
                     f"Pick a [train] inference_gpus from that set (e.g. a 1:2 or 1:4 split)."
                 )
+        # Optional --enforce_eager: skip vLLM CUDA-graph capture at server boot. For very large
+        # models (e.g. the 35B-A3B MoE) graph capture dominates the boot window and can blow past
+        # RL_VLLM_SERVER_TIMEOUT before the server is ever healthy; eager trades a little decode
+        # throughput for a tractable boot. Opt-in via AUTOSLM_RL_VLLM_ENFORCE_EAGER so small models
+        # keep graphs (their boot is cheap and they want the decode speed).
+        _vllm_extra: list[str] = []
+        if os.environ.get("AUTOSLM_RL_VLLM_ENFORCE_EAGER", "").strip().lower() in ("1", "true", "yes"):
+            _vllm_extra += ["--enforce_eager", "true"]
         _cmd = _disagg.build_vllm_serve_cmd(
             model_id,
             _rollout_split,
@@ -1905,6 +1957,7 @@ def run_rl():
             quant=quant,
             kv_cache_dtype=_server_kv,
             parallel=_parallel,
+            extra=(_vllm_extra or None),
         )
         _server_timeout = float(os.environ.get("RL_VLLM_SERVER_TIMEOUT", "1200"))
         if _trainer_only:
@@ -1922,8 +1975,17 @@ def run_rl():
             # take longer, so default generously (uvicorn binds the HTTP port only AFTER the worker
             # finishes loading, so the health check sees connection-refused until then).
             try:
+                # Emit a heartbeat every 60s during the boot so the control plane's no-heartbeat
+                # STALL detector (~25 min) doesn't kill a big model mid-boot: the 35B server
+                # (70 GB bf16 + tilelang/CUDA-graph JIT) can take >20 min to bind its port, and that
+                # whole stretch is silent otherwise. (This was why the 35B run got killed at 1503s.)
+                _boot_t0 = time.time()
                 _disagg.wait_for_server_health(
-                    _port, timeout=_server_timeout, proc=vllm_proc, log_path=_server_log
+                    _port,
+                    timeout=_server_timeout,
+                    proc=vllm_proc,
+                    log_path=_server_log,
+                    on_wait=lambda: heartbeat("rl_server_boot", boot_seconds=round(time.time() - _boot_t0)),
                 )
             except BaseException:
                 # A server boot failure / health-check error here must NOT leak the vllm-serve
@@ -2125,7 +2187,14 @@ def run_rl():
             import subprocess as _sp
 
             t_train = time.time()
-            _acc_cmd = _disagg.build_accelerate_launch_cmd(_rollout_split)
+            # Use DDP (replicate the model on each trainer rank), NOT FSDP sharding. TRL's per-step
+            # weight sync calls peft merge_adapter()->get_delta_weight (weight_B @ weight_A); FSDP
+            # (FULL_SHARD and even SHARD_GRAD_OP) flattens/shards the LoRA params so the merge fails
+            # ("inconsistent tensor size [32768] vs [24576]"). DDP keeps each param whole on every
+            # rank, so the merge works. Every model that runs a multi-trainer ratio here (1-9B)
+            # fits replicated on one trainer card; the only model that wouldn't (35B) uses the
+            # single-trainer 1:1 path, so DDP covers all the 2:1/2:2/3:1 ratios.
+            _acc_cmd = _disagg.build_accelerate_launch_cmd(_rollout_split, use_fsdp=False)
             _child_env = dict(os.environ)
             _child_env["AUTOSLM_RL_TRAINER_ONLY"] = "1"
             _child_env["AUTOSLM_VLLM_SERVER_PORT"] = str(_port)
@@ -2135,11 +2204,23 @@ def run_rl():
             # device placement across the train GPUs.
             _child_env.pop("CUDA_VISIBLE_DEVICES", None)
             print(f"[rl][disagg][fsdp] launching FSDP trainer group ({_rollout_split.label}): {' '.join(_acc_cmd)}")
-            _rc = _sp.run(_acc_cmd, env=_child_env).returncode
+            # Capture the child group's stdout+stderr to a file and ALWAYS upload it: the launcher's
+            # own console is not reliably captured once the child writes DONE, so this is the only way
+            # to see the FSDP trainer's behavior (real steps vs 0-step empty run) for debugging.
+            _child_log = "/tmp/fsdp_child.log"
+            with open(_child_log, "w") as _clf:
+                _rc = _sp.run(_acc_cmd, env=_child_env, stdout=_clf, stderr=_sp.STDOUT).returncode
+            print("[rl][disagg][fsdp] --- accelerate child log tail (last 160) ---")
+            print(_disagg._server_log_tail(_child_log, n=160))
+            print("[rl][disagg][fsdp] --- end child log ---", flush=True)
+            try:
+                hf_upload_file(_child_log, "console_fsdp_child.txt")
+            except Exception as _e:
+                print(f"[rl][disagg][fsdp] could not upload child log: {_e}")
             if _rc != 0:
                 raise RuntimeError(
                     f"accelerate FSDP trainer group exited {_rc} (split {_rollout_split.label}); "
-                    "see error_rl.txt / console_rl.txt"
+                    "see console_fsdp_child.txt"
                 )
             print("[rl][disagg][fsdp] trainer group finished; artifacts written by rank 0")
         else:

code/autoslm/providers/allocator.py

@@ -52,6 +52,7 @@ def required_vram_gb(
     *,
     train=None,
     thinking: bool = False,
+    gpu_count: int = 1,
 ) -> int:
     """VRAM the full run needs, sized to the run's actual knobs (context length, LoRA
     rank, batch / group size, thinking) via the shared ``model_required_vram_gb`` matrix.
@@ -62,13 +63,74 @@ def required_vram_gb(
     when unreadable (handled inside model_required_vram_gb)."""
     from autoslm.engine.vram import model_required_vram_gb
 
-    return model_required_vram_gb(
+    colocate = model_required_vram_gb(
         model_id,
         algorithm,
         train=train,
         thinking=thinking,
         headroom=vram_headroom(),
     )
+    # Disaggregated GRPO ([train].inference_gpus>0) splits memory across the node's GPUs: the
+    # inference server (full bf16 weights + KV) and the trainer (quant weights + LoRA optimizer +
+    # activations) live on SEPARATE cards, so no single GPU needs the colocate total. The binding
+    # per-GPU need is max(server bf16 weights + KV/overhead, the trainer's share ~= colocate minus
+    # the vLLM engine/KV). Sizing to that lets a big model fit a per-role card (e.g. Qwen3.6-35B-A3B
+    # served bf16 on a 94GB H100 NVL, 4-bit trainer on the other) instead of demanding the colocate
+    # floor (~96GB) — which no available 2-GPU node meets — while staying FLOORED by the bf16 weights
+    # so the server can never be under-provisioned into an OOM. Also unblocks 4B 1:2 on a 5090 (the
+    # disaggregated server/trainer each fit 32GB though colocate 4B needs ~35GB).
+    if train is not None and int(getattr(train, "inference_gpus", 0) or 0) > 0:
+        pb = _params_b_for_vram(model_id)
+        if pb:
+            infer = max(1, int(getattr(train, "inference_gpus", 1) or 1))
+            # Total GPUs on the node (rollout + trainer). The trainer pool is everything that
+            # isn't a rollout GPU; default to a single trainer when the caller didn't pass a count
+            # (the colocate cap below still protects that degenerate case).
+            total = max(infer + 1, int(gpu_count or (infer + 1)))
+            n_trainer = max(1, total - infer)
+            base = 2.0 * pb  # frozen base model, bf16, ALL params resident (MoE: every expert loaded)
+
+            # ROLLOUT card. The baked verl default is DATA-PARALLEL (TP=1) — each replica holds the
+            # FULL base + KV. A base too large to fit one 80GB card as a DP replica is served
+            # TENSOR-PARALLEL across the inference GPUs instead (verl_runner auto-bumps
+            # AUTOSLM_VERL_ROLLOUT_TP to match), so size per shard. Floors the per-card need so the
+            # inference GPU is never under-provisioned into a KV/weights OOM.
+            rollout_tp = infer if (base * 1.35 + 4) > 78 else 1
+            rollout_need = int(base * 1.35 / rollout_tp) + 4  # weights/shard + KV / CUDA-graph / overhead
+
+            # TRAINER card. FSDP2 shards the frozen base (+ tiny LoRA grads/optim) across the
+            # n_trainer trainer GPUs; activations and the one_step_off *bucketed* weight-transfer
+            # staging do NOT shard, so floor each card at base/n_trainer + a bounded transfer buffer +
+            # fixed overhead. n_trainer==1 keeps the whole base on one card (matches the observed 4B
+            # one-trainer OOM on a 24GB card — needed ~26GB, fits 40GB — while 4B sharded across two
+            # trainers fits 24GB). The bucketed sync stages only a few layers, NOT a full second copy,
+            # so 35B-A3B (70GB base) trains across 2 trainers at ~58GB/card and fits an 80GB H100/A100.
+            transfer_buf = min(0.5 * base, 10.0)
+            trainer_need = int(base / n_trainer + transfer_buf + 13)
+
+            # Per-card requirement is the heavier role on a homogeneous node. This is already a true
+            # per-card figure (both roles divided by their parallel degree), so no colocate cap — a
+            # multi-GPU FSDP/TP split legitimately needs LESS per card than the whole colocated total.
+            return max(rollout_need, trainer_need)
+    return colocate
+
+
+def _params_b_for_vram(model_id: str) -> float | None:
+    """Param count (billions) for disaggregated VRAM sizing: catalog first, then HF metadata."""
+    from autoslm.engine.vram import fetch_hf_params_b, params_b_from_str
+
+    try:
+        from autoslm.catalog import get_model
+
+        pb = params_b_from_str(getattr(get_model(model_id), "params", None))
+        if pb:
+            return pb
+    except Exception:
+        pass
+    try:
+        return fetch_hf_params_b(model_id)
+    except Exception:
+        return None
 
 
 def _runpod_candidates(need: int, pinned_gpu: str | None, allow_unval: bool) -> list[Candidate]:
@@ -185,7 +247,7 @@ def allocate(
     # pin (e.g. Qwen3-8B on a 24 GB card) must drop out of the candidate filter and
     # raise here, not provision a paid worker that OOMs. The pin only narrows WHICH
     # fitting class is chosen, never lowers the VRAM bar.
-    need = required_vram_gb(model_id, algorithm, train=train, thinking=thinking)
+    need = required_vram_gb(model_id, algorithm, train=train, thinking=thinking, gpu_count=gpu_count)
     allow_unval = unvalidated_allowed(allow_unvalidated)
     live = available_providers()
     if provider != "auto" and provider not in live:

code/autoslm/providers/runpod/jobs.py

@@ -62,10 +62,14 @@ TERMINAL_FAIL = {"FAILED", "CANCELLED", "TIMED_OUT"}
 
 # Heartbeat stages the worker emits DURING cold start, BEFORE the model is loaded and the
 # training loop begins (boot -> sft_start/rl_start, then later sft_model_load/rl_train_start).
+# ``rl_server_boot`` is the disaggregated (multi-GPU) rollout server's boot heartbeat, emitted
+# every ~60s while vLLM loads the model and binds its port — still pre-training, so it likewise
+# stays under setup_grace_s (otherwise the FIRST boot ping would prematurely flip to the tight
+# training window while the server is still booting).
 # Receiving one proves the worker is alive but NOT that the slow setup (model download +
 # vLLM init) finished, so they must not flip stall detection to the tight training window.
 _SETUP_HEARTBEAT_STAGES = frozenset(
-    {"boot", "sft_start", "rl_start", "sft_model_load", "rl_train_start"}
+    {"boot", "sft_start", "rl_start", "sft_model_load", "rl_train_start", "rl_server_boot"}
 )
 
 
@@ -404,8 +408,15 @@ def submit_run(spec, seed: int, log=None, on_handle=None, attempt: int = 0) -> P
         "extra_pip": extra_pip,
         "hub_env_ids": worker_hub_env_ids(spec.environment.id, spec.environment.params),
     }
+    # The BAKED worker image ships a custom /rp_handler.py whose handler calls
+    # ``_train_body(job["input"])`` directly, so the job input must be the RAW payload. The
+    # ``build_function_input`` FunctionRequest envelope ({function_name, function_code, args}) is
+    # ONLY for the live runpod_flash runtime (no image), which deserializes ``args`` before calling
+    # ``_train_body``. Sending the envelope to the baked handler made it read the envelope as
+    # ``input_data`` -> ``input_data["hf_repo"]`` KeyError. Pick the shape that matches the runtime.
+    job_input = payload if WORKER_IMAGE else build_function_input(payload, spec.gpu.type)
     try:
-        job_id = runpod_api.submit_job(endpoint_id, build_function_input(payload, spec.gpu.type))
+        job_id = runpod_api.submit_job(endpoint_id, job_input)
     except Exception:
         # The endpoint is registered but no run handle exists yet, and a
         # retry endpoint's rN-suffixed name can't be reconstructed from the run

code/autoslm/providers/runpod/train.py

@@ -183,11 +183,22 @@ def upload_code(repo: str | None = None) -> str:
     # downloads (worker gets 403), so operators on a free tier must publish artifact repos
     # public. Default private (paid-tier safe); set AUTOSLM_HF_REPO_PRIVATE=0 to create public.
     private = os.environ.get("AUTOSLM_HF_REPO_PRIVATE", "1") not in ("0", "false", "False")
-    api.create_repo(repo, repo_type="dataset", exist_ok=True, private=private)
+    # HF caps repository CREATION at 300/day per account; create_repo(exist_ok=True) still POSTs to
+    # /api/repos/create (the 409 is swallowed client-side) and so each call counts against that cap.
+    # A benchmark/sweep that uses one HF repo per run blows the cap fast. Gate the create on a cheap
+    # repo_exists() GET (not rate-limited) so reusing an existing artifact repo makes ZERO creation
+    # calls — only a genuinely new repo hits the create endpoint.
+    already = False
+    try:
+        already = api.repo_exists(repo, repo_type="dataset")
+    except Exception:
+        already = False
+    if not already:
+        api.create_repo(repo, repo_type="dataset", exist_ok=True, private=private)
     # create_repo(exist_ok=True) is a no-op on an EXISTING repo, so it never flips a repo that
     # already exists private back to public. When the operator wants public (free-tier: workers
     # 403 on private downloads), force visibility explicitly so a reused private repo is fixed.
-    if not private:
+    if not private and not already:
         try:
             api.update_repo_settings(repo_id=repo, repo_type="dataset", private=False)
         except Exception as e: