Upload folder using huggingface_hub

code/autoslm/__init__.py

@@ -0,0 +1,11 @@
+"""AutoSLM — managed LoRA post-training: log in with your freesolo key, train.
+
+A focused developer experience (TOML run specs, pluggable environments,
+CLI/API/MCP entry points, adapter deployment). Users authenticate with their
+freesolo API key (`slm login`); the control plane runs each job on a managed
+GPU (RunPod or Vast.ai) behind the scenes.
+"""
+
+__all__ = ["__version__"]
+
+__version__ = "0.2.0"

code/autoslm/_logging.py

@@ -0,0 +1,66 @@
+"""Package logging helpers.
+
+Library code logs through the ``autoslm`` logger and never configures handlers on import (it
+attaches a :class:`logging.NullHandler`), so importing AutoSLM stays silent for downstream
+applications. The CLI calls :func:`configure_logging` to attach a console handler whose
+level is controlled by ``-v/--verbose`` or the ``AUTOSLM_LOG_LEVEL`` environment variable.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+
+_ROOT_NAME = "autoslm"
+
+# Attach a NullHandler once so "No handlers could be found" warnings never appear and
+# importing the library produces no output unless the app opts in.
+_root = logging.getLogger(_ROOT_NAME)
+if not any(isinstance(h, logging.NullHandler) for h in _root.handlers):
+    _root.addHandler(logging.NullHandler())
+
+
+def get_logger(name: str | None = None) -> logging.Logger:
+    """Return a logger under the ``autoslm`` namespace (e.g. ``get_logger(__name__)``)."""
+    if not name or name == _ROOT_NAME:
+        return logging.getLogger(_ROOT_NAME)
+    if name.startswith(_ROOT_NAME + "."):
+        return logging.getLogger(name)
+    return logging.getLogger(f"{_ROOT_NAME}.{name}")
+
+
+def _level_from_env(default: int = logging.WARNING) -> int:
+    raw = os.environ.get("AUTOSLM_LOG_LEVEL")
+    if not raw:
+        return default
+    raw = raw.strip()
+    if raw.isdigit():
+        return int(raw)
+    # Map names (INFO/DEBUG/...) to ints via the canonical name->level mapping rather
+    # than logging.getLevelName, whose name->int behaviour is deprecated and which
+    # returns "Level FOO" for unknown names instead of signalling failure.
+    return logging.getLevelNamesMapping().get(raw.upper(), default)
+
+
+def configure_logging(verbosity: int = 0, level: int | None = None) -> None:
+    """Attach a console handler to the ``autoslm`` logger and set its level.
+
+    ``verbosity`` maps repeated ``-v`` flags to levels (0=WARNING, 1=INFO, >=2=DEBUG).
+    An explicit ``level`` (or the ``AUTOSLM_LOG_LEVEL`` env var) overrides the verbosity mapping.
+    """
+    if level is None:
+        if os.environ.get("AUTOSLM_LOG_LEVEL"):
+            level = _level_from_env()
+        else:
+            level = {0: logging.WARNING, 1: logging.INFO}.get(verbosity, logging.DEBUG)
+
+    logger = logging.getLogger(_ROOT_NAME)
+    logger.setLevel(level)
+    # Replace any prior console handler we installed so repeated calls don't stack handlers.
+    for h in [h for h in logger.handlers if getattr(h, "_autoslm_console", False)]:
+        logger.removeHandler(h)
+    handler = logging.StreamHandler()  # stderr
+    handler.setLevel(level)
+    handler.setFormatter(logging.Formatter("%(levelname)s %(name)s: %(message)s"))
+    handler._autoslm_console = True  # type: ignore[attr-defined]
+    logger.addHandler(handler)

code/autoslm/catalog.py

@@ -0,0 +1,240 @@
+"""Curated model catalog for one-consumer-GPU LoRA jobs."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import asdict, dataclass
+from typing import Any
+
+ALGORITHMS = ("sft", "grpo")
+
+
+def normalize_algorithm(value: str) -> str:
+    """Canonical (lowercased, validated) algorithm name."""
+    value = (value or "grpo").lower()
+    if value not in ALGORITHMS:
+        raise ValueError(f"unsupported algorithm: {value}; known: {', '.join(ALGORITHMS)}")
+    return value
+
+
+# The default GPU class a run lands on when none is pinned (also the open-model-policy
+# sizing reference and the spec/from_dict fallback). The validated GPU class set
+# (SUPPORTED/is_validated) lives in providers.base; per-provider classes and pricing live
+# under providers/{runpod,vast}. Defined above ModelInfo so it can back the
+# recommended_gpu field default.
+DEFAULT_GPU = "RTX 5090"
+
+
+@dataclass(frozen=True)
+class ModelInfo:
+    id: str
+    display_name: str
+    params: str
+    algos: tuple[str, ...]
+    min_vram_gb: int
+    quant: str = "bf16"
+    recommended_gpu: str = DEFAULT_GPU
+    # GRPO needs more VRAM than SFT (a colocated vLLM rollout engine holds a second copy of
+    # the weights + KV cache). 0 => GRPO uses ``min_vram_gb`` like SFT; set it when the GRPO
+    # tier needs a bigger card than SFT (the colocate 2nd weight copy + KV pool). Consumed by
+    # engine.vram.model_required_vram_gb.
+    grpo_min_vram_gb: int = 0
+    notes: str = ""
+    # Worker container disk this model needs (GB). 0 = the platform default (64 GB)
+    # suffices. The runner raises gpu.disk_gb to at least this, so big-checkpoint
+    # models whose weights alone exceed 64 GB work out of the box.
+    min_disk_gb: int = 0
+    # Thinking/reasoning capability of the checkpoint's chat template:
+    #   "none"    no <think> support (or a non-thinking variant) — `thinking = true` is
+    #             rejected for these models
+    #   "hybrid"  template honors enable_thinking (Qwen3-style hybrid reasoning)
+    #   "always"  the model always emits reasoning; enable_thinking can't turn it off,
+    #             so `thinking = true` is required
+    #   "unknown" open-model-policy entries (capability not verified)
+    thinking: str = "none"
+    # Requires the DISAGGREGATED (multi-GPU async) GRPO path: too large to colocate the trainer +
+    # vLLM rollout on one GPU. A GRPO request for such a model must set ``[train].inference_gpus>0``
+    # on a multi-GPU node (see engine.rollout_bench); colocate GRPO is rejected. SFT is unaffected.
+    requires_disaggregated: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+# The default model AutoSLM trains when a config omits one. A current-gen dense 4B
+# (text-only fine-tune) on the modern worker stack — the safe out-of-the-box choice for
+# the average developer. It is thinking-"hybrid"; the thinking flag now defaults ON.
+DEFAULT_MODEL = "Qwen/Qwen3.5-4B"
+
+MODELS: dict[str, ModelInfo] = {
+    "openbmb/MiniCPM5-1B": ModelInfo(
+        id="openbmb/MiniCPM5-1B",
+        display_name="MiniCPM5 1B",
+        params="1.2B dense (Llama arch)",
+        algos=("sft", "grpo"),
+        min_vram_gb=12,
+        recommended_gpu="RTX 4090",
+        thinking="hybrid",
+        notes="On-device class SLM (131k ctx); standard Llama architecture.",
+    ),
+    # ---- Qwen3.5 dense family: validated on the modern worker stack ----
+    # (trl 1.x / vllm 0.19 / transformers 5.x). Trained + served TEXT-ONLY: the
+    # checkpoints are natively multimodal, so LoRA excludes the vision tower and vLLM
+    # loads language_model_only (see autoslm.engine.worker). Each entry passed a real
+    # train+eval smoke on its recommended GPU (bench/results/phase1/).
+    "Qwen/Qwen3.5-0.8B": ModelInfo(
+        id="Qwen/Qwen3.5-0.8B",
+        display_name="Qwen3.5 0.8B",
+        params="0.9B (text-only fine-tune)",
+        algos=("sft", "grpo"),
+        min_vram_gb=12,
+        recommended_gpu="RTX 4090",
+        thinking="hybrid",
+        notes="Smallest Qwen3.5; cheap smoke/dev runs with the modern arch.",
+    ),
+    "Qwen/Qwen3.5-2B": ModelInfo(
+        id="Qwen/Qwen3.5-2B",
+        display_name="Qwen3.5 2B",
+        params="2.3B (text-only fine-tune)",
+        algos=("sft", "grpo"),
+        min_vram_gb=16,
+        recommended_gpu="RTX 4090",
+        thinking="hybrid",
+    ),
+    "Qwen/Qwen3.5-4B": ModelInfo(
+        id="Qwen/Qwen3.5-4B",
+        display_name="Qwen3.5 4B",
+        params="4.7B (text-only fine-tune)",
+        algos=("sft", "grpo"),
+        min_vram_gb=32,
+        recommended_gpu="RTX 5090",
+        thinking="hybrid",
+        notes="Current-gen 4B. GRPO uses the sleep-mode memory recipe (hybrid arch needs "
+        "extra engine state-cache); fused DeltaNet kernels ship in the default stack.",
+    ),
+    "Qwen/Qwen3.5-9B": ModelInfo(
+        id="Qwen/Qwen3.5-9B",
+        display_name="Qwen3.5 9B",
+        params="9.7B (text-only fine-tune)",
+        algos=("sft", "grpo"),
+        min_vram_gb=16,
+        # MEMORY-OPTIMIZED: 4-bit NF4 frozen base + bf16 LoRA adapter (QLoRA). The base
+        # drops from ~19 GB bf16 to ~5.3 GB, so colocated GRPO holds two 4-bit copies
+        # (trainer + bnb-quantized vLLM rollout) instead of two bf16 copies -> it fits a
+        # ~24-32 GB card instead of an 80 GB A100. NF4 is near-lossless for adapter training
+        # (QLoRA paper + follow-ups), a small quality trade for a ~3x cheaper GPU. No GRPO
+        # floor: the matrix sizes the (much smaller) 4-bit footprint directly.
+        grpo_min_vram_gb=0,
+        quant="4bit-qlora",
+        recommended_gpu="RTX 5090",
+        thinking="hybrid",
+        notes="QLoRA (4-bit NF4 base + bf16 LoRA). GRPO's colocated vLLM rollout loads the "
+        "base 4-bit via bitsandbytes too, so both copies are 4-bit -> fits ~24-32 GB "
+        "instead of 80 GB bf16. ~near-lossless vs bf16 LoRA.",
+    ),
+    "Qwen/Qwen3.6-35B-A3B": ModelInfo(
+        id="Qwen/Qwen3.6-35B-A3B",
+        display_name="Qwen3.6 35B-A3B (MoE)",
+        params="35B total / ~3B active (MoE)",
+        algos=("sft", "grpo"),
+        min_vram_gb=48,
+        grpo_min_vram_gb=80,
+        quant="4bit-qlora",
+        recommended_gpu="A100 PCIe",
+        thinking="hybrid",
+        # Re-added for the DISAGGREGATED (multi-GPU async) GRPO path only: it OOMs when the trainer
+        # and the vLLM rollout are colocated on one card. With a dedicated inference GPU (35B served
+        # 4-bit) + a sharded trainer on the rest, it fits. GRPO colocate for it is rejected.
+        requires_disaggregated=True,
+        notes="MoE; GRPO requires the disaggregated multi-GPU node ([train].inference_gpus>0). "
+        "The 35B is served 4-bit on the inference GPU while a sharded trainer runs on the rest.",
+    ),
+}
+
+
+def list_models() -> list[ModelInfo]:
+    return sorted(MODELS.values(), key=lambda m: (m.min_vram_gb, m.id))
+
+
+def get_model(model_id: str) -> ModelInfo:
+    try:
+        return MODELS[model_id]
+    except KeyError as exc:
+        allowed = ", ".join(MODELS)
+        raise ValueError(
+            f"unsupported model {model_id!r}; choose one of: {allowed} — or set "
+            f'model_policy = "allow" in the config to run any HF model that fits the GPU '
+            f"(open-model policy)"
+        ) from exc
+
+
+def resolve_model(
+    model_id: str,
+    algorithm: str,
+    policy: str = "catalog",
+    gpu: str | None = None,
+) -> ModelInfo:
+    """Resolve a model under the configured policy.
+
+    ``catalog`` (default): the model must be a curated catalog entry.
+    ``allow``: any HF model is accepted; a coarse VRAM-fit estimate (HF safetensors
+    metadata, no download) blocks only provably-impossible fits and warns on tight ones.
+    """
+    algo = normalize_algorithm(algorithm)
+    if model_id in MODELS:
+        return validate_model_for_algorithm(model_id, algo)
+    if policy != "allow":
+        # Reuse get_model's error (includes the open-model hint).
+        return get_model(model_id)
+    return _resolve_open_model(model_id, algo, gpu)
+
+
+def _resolve_open_model(model_id: str, algo: str, gpu: str | None) -> ModelInfo:
+    """Synthesize a ModelInfo for the open-model "allow" policy from a coarse VRAM-fit
+    estimate (HF safetensors metadata, no download). Blocks provably-impossible fits and
+    warns on tight ones. Isolates the engine.vram dependency + disk-floor heuristic from
+    the curated-catalog path in resolve_model."""
+    from autoslm.engine.vram import check_fit
+
+    est = check_fit(model_id, algo, gpu or DEFAULT_GPU)
+    if est.verdict == "too_big":
+        raise ValueError(
+            f"{model_id} does not fit the requested GPU: {est.describe()}. "
+            f"Pick a smaller model or a larger supported GPU."
+        )
+    if est.verdict in ("tight", "unknown"):
+        print(f"warning: open-model policy: {est.describe()}")
+    params = f"{est.params_b:.1f}B" if est.params_b else "unknown size"
+    # Disk floor for the open model: a bf16 checkpoint is ~2 GB per billion params;
+    # add worker-stack headroom so a large model that passes the VRAM check can't
+    # provision a paid worker and then fail in prefetch_model when the checkpoint
+    # overflows the 64 GB container default. 0 (unknown size) leaves the default
+    # (the user can still raise it with gpu.disk_gb).
+    min_disk = int(est.params_b * 2) + 64 if est.params_b else 0
+    return ModelInfo(
+        id=model_id,
+        display_name=model_id,
+        params=params,
+        algos=ALGORITHMS,
+        min_vram_gb=math.ceil(est.est_gb) if est.est_gb else 24,
+        min_disk_gb=min_disk,
+        recommended_gpu=gpu or DEFAULT_GPU,
+        thinking="unknown",
+        notes="unlisted model accepted via the open-model policy (not curated/validated)",
+    )
+
+
+def validate_model_for_algorithm(model_id: str, algorithm: str) -> ModelInfo:
+    info = get_model(model_id)
+    algo = normalize_algorithm(algorithm)
+    # Catalog entries advertise the capability classes "sft" and "grpo": grpo needs the
+    # colocated rollout engine, sft is trainer-only.
+    required = "grpo" if algo == "grpo" else "sft"
+    if required not in info.algos:
+        allowed = ", ".join(info.algos)
+        raise ValueError(f"{model_id} supports {allowed}, not {algo}")
+    return info
+
+
+def public_model_rows() -> list[dict[str, Any]]:
+    return [m.to_dict() for m in list_models()]

code/autoslm/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI package."""

code/autoslm/cli/main.py

@@ -0,0 +1,920 @@
+"""CLI for the managed AutoSLM service.
+
+Every run-lifecycle command is a thin HTTP call to the AutoSLM control plane —
+users authenticate with their freesolo API key (`slm login` verifies it against
+the freesolo backend), never with provider credentials. Config parsing/validation
+and `--dry-run` stay fully local.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+from autoslm import __version__
+from autoslm._logging import configure_logging, get_logger
+from autoslm.catalog import public_model_rows
+from autoslm.client import (
+    ApiClient,
+    ClientError,
+    client_from_config,
+    save_credentials,
+    verify_freesolo_key,
+)
+from autoslm.client.config import load_credentials
+from autoslm.client.specs import spec_payload
+from autoslm.runner import TERMINAL_STATES, new_run_id
+from autoslm.schema import ConfigError, spec_from_file
+from autoslm.spec import _coerce_bool
+
+logger = get_logger(__name__)
+
+
+# Exceptions that represent expected user/config errors: report them as a clean one-line
+# message instead of a Python traceback (use --debug / AUTOSLM_DEBUG=1 to see the full trace).
+_USER_ERRORS = (
+    ConfigError,
+    ClientError,
+    FileNotFoundError,
+    ValueError,
+)
+
+# Run states after which nothing more will happen (polling can stop).
+_CLI_DONE_STATES = TERMINAL_STATES | {"deployed"}
+_OK_STATES = {"done", "dry_run", "deployed"}
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="slm", description="Managed LoRA post-training")
+    parser.add_argument("-V", "--version", action="version", version=f"slm {__version__}")
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="show full tracebacks on error (or set AUTOSLM_DEBUG=1)",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="increase log verbosity (-v for info, -vv for debug; or set AUTOSLM_LOG_LEVEL)",
+    )
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    version = sub.add_parser("version", help="print the AutoSLM version")
+    version.set_defaults(func=cmd_version)
+
+    login = sub.add_parser("login", help="log in with your freesolo API key (verified by freesolo)")
+    login.add_argument(
+        "--api-key",
+        help="your freesolo API key (default: FREESOLO_API_KEY); created in the dashboard",
+    )
+    login.add_argument(
+        "--freesolo-url",
+        dest="freesolo_url",
+        help="freesolo backend base URL (default: FREESOLO_BASE_URL or https://api.freesolo.co)",
+    )
+    login.add_argument(
+        "--api-url", help="autoslm control-plane URL for training calls (default: AUTOSLM_API_URL)"
+    )
+    login.set_defaults(func=cmd_login)
+
+    whoami = sub.add_parser("whoami", help="show the identity behind your stored key")
+    whoami.set_defaults(func=cmd_whoami)
+
+    lab = sub.add_parser("lab", help="local authoring scaffolds")
+    lab_sub = lab.add_subparsers(dest="lab_cmd", required=True)
+    setup = lab_sub.add_parser("setup", help="scaffold environments/ + configs/ in the cwd")
+    setup.set_defaults(func=cmd_lab_setup)
+
+    models = sub.add_parser("models", help="list supported base models")
+    models.set_defaults(func=cmd_models)
+
+    gpus = sub.add_parser("gpus", help="list managed GPU classes with live $/hr")
+    gpus.set_defaults(func=cmd_gpus)
+
+    env = sub.add_parser("env", help="manage verifiers environments")
+    env_sub = env.add_subparsers(dest="env_cmd", required=True)
+    init = env_sub.add_parser("init", help="scaffold a new local verifiers environment")
+    init.add_argument("name")
+    init.set_defaults(func=cmd_env_init)
+
+    env_list = env_sub.add_parser("list", help="list installed + local environments")
+    env_list.set_defaults(func=cmd_env_list)
+
+    env_install = env_sub.add_parser("install", help="install a published Prime Hub environment")
+    env_install.add_argument("env_id", help='the env id to install (a Hub slug, "owner/name")')
+    env_install.set_defaults(func=cmd_env_install)
+
+    env_push = env_sub.add_parser(
+        "push", help="publish a local verifiers env to the Prime Hub (private); prints its env id"
+    )
+    env_push.add_argument("path", nargs="?", default=".")
+    env_push.set_defaults(func=cmd_env_push)
+
+    train = sub.add_parser("train", help="submit a managed training run from a TOML config")
+    train.add_argument("config")
+    train.add_argument(
+        "--config",
+        dest="extra_configs",
+        action="append",
+        default=[],
+        help="additional TOML to deep-merge (config composition); repeatable",
+    )
+    train.add_argument(
+        "--set",
+        dest="overrides",
+        action="append",
+        default=[],
+        metavar="key=value",
+        help="override a config value; repeatable",
+    )
+    train.add_argument("--dry-run", action="store_true")
+    train.add_argument(
+        "--background",
+        action="store_true",
+        help="submit and return immediately instead of following logs",
+    )
+    train.set_defaults(func=cmd_train)
+
+    status = sub.add_parser("status", help="show a run's full status JSON")
+    status.add_argument("run_id")
+    status.set_defaults(func=cmd_status)
+
+    attach = sub.add_parser(
+        "attach", help="follow a running job's logs to completion (resumable any time)"
+    )
+    attach.add_argument("run_id")
+    attach.set_defaults(func=cmd_attach)
+
+    ps = sub.add_parser("ps", help="list runs and their state/cost")
+    ps.set_defaults(func=cmd_ps)
+
+    cost = sub.add_parser("cost", help="show a run's accrued cost (USD)")
+    cost.add_argument("run_id")
+    cost.set_defaults(func=cmd_cost)
+
+    cancel = sub.add_parser("cancel", help="cancel a run (best-effort)")
+    cancel.add_argument("run_id")
+    cancel.set_defaults(func=cmd_cancel)
+
+    logs = sub.add_parser("logs")
+    logs.add_argument("run_id")
+    logs.add_argument("-f", "--follow", action="store_true", help="stream new log lines")
+    logs.set_defaults(func=cmd_logs)
+
+    deploy = sub.add_parser("deploy")
+    deploy.add_argument("run_id")
+    deploy.add_argument(
+        "--mode",
+        choices=["dev", "always-on"],
+        default="dev",
+        help="dev: scale-to-zero, cold start after idle, $0 when unused (default). "
+        "always-on: one warm worker 24/7, no cold starts, continuous billing.",
+    )
+    deploy.add_argument(
+        "--idle-timeout",
+        type=int,
+        default=300,
+        help="dev mode: seconds of inactivity before the worker scales to zero (default 300)",
+    )
+    deploy.add_argument("--dry-run", action="store_true")
+    deploy.set_defaults(func=cmd_deploy)
+
+    undeploy = sub.add_parser("undeploy", help="tear down a run's serving endpoint")
+    undeploy.add_argument("run_id")
+    undeploy.set_defaults(func=cmd_undeploy)
+
+    deployments = sub.add_parser("deployments", help="list active serving deployments")
+    deployments.set_defaults(func=cmd_deployments)
+
+    chat = sub.add_parser("chat", help="chat with a deployed adapter")
+    chat.add_argument("run_id")
+    chat.add_argument("-m", "--message", required=True)
+    chat.add_argument("--max-tokens", type=int, default=512)
+    chat.add_argument("--temperature", type=float, default=0.0)
+    chat.set_defaults(func=cmd_chat)
+
+    # The control plane is operator-only and run as a separate one-off service via the
+    # `autoslm-server` console script (autoslm.server.__main__:main), not a `slm` subcommand.
+
+    args = parser.parse_args(argv)
+    configure_logging(verbosity=getattr(args, "verbose", 0))
+    debug = getattr(args, "debug", False) or _coerce_bool(os.environ.get("AUTOSLM_DEBUG", ""))
+    try:
+        return args.func(args)
+    except _USER_ERRORS as exc:
+        if debug:
+            raise
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print("aborted", file=sys.stderr)
+        return 130
+
+
+def cmd_version(args) -> int:
+    print(f"slm {__version__}")
+    return 0
+
+
+def cmd_login(args) -> int:
+    # Login is handled by the freesolo backend (not the autoslm control plane): the user
+    # supplies the freesolo API key they created in the dashboard, and we verify it against
+    # freesolo before storing it. The same key authenticates autoslm's control plane.
+    api_key = args.api_key or os.environ.get("FREESOLO_API_KEY")
+    if not api_key:
+        raise ClientError(
+            "no API key provided: pass `--api-key <key>` or set FREESOLO_API_KEY. "
+            "Create a key in your freesolo dashboard."
+        )
+    verify_freesolo_key(api_key, base_url=getattr(args, "freesolo_url", None))
+    api_url = args.api_url or load_credentials()[0]
+    # save_credentials clears the stored url when it's the default, so logging into the
+    # default plane also drops a stale custom url from a previous custom-URL login.
+    path = save_credentials(api_key, api_url=api_url)
+    # Never echo the key itself; the stored file is the single source of truth.
+    print(f"logged in: freesolo verified your key (saved to {path})")
+    print("you're ready to train — try `slm train <config.toml>`")
+    return 0
+
+
+def cmd_whoami(args) -> int:
+    print(json.dumps(client_from_config().me(), indent=2))
+    return 0
+
+
+_STARTER_ENV_PY = '''\
+"""Starter local verifiers environment.
+
+Replace the dataset and rubric with your task, then publish it to the Prime Hub with
+`slm env push environments/starter_env.py`. A managed run references the published env by
+its Hub slug: set [environment] id = "owner/name" in the config.
+See https://github.com/PrimeIntellect-ai/verifiers for the full API.
+"""
+
+import verifiers as vf
+from datasets import Dataset
+
+
+def load_environment(**kwargs) -> vf.Environment:
+    dataset = Dataset.from_list(
+        [
+            {"prompt": [{"role": "user", "content": "What is 2 + 2?"}], "answer": "4"},
+            {"prompt": [{"role": "user", "content": "What is 3 + 5?"}], "answer": "8"},
+        ]
+    )
+
+    def correct_answer(completion, answer, **_):
+        """Reward 1.0 when the gold answer appears in the model's final message."""
+        text = completion[-1]["content"] if isinstance(completion, list) else str(completion)
+        return 1.0 if str(answer) in text else 0.0
+
+    rubric = vf.Rubric(funcs=[correct_answer], weights=[1.0])
+    return vf.SingleTurnEnv(dataset=dataset, rubric=rubric, **kwargs)
+'''
+
+
+def cmd_lab_setup(args) -> int:
+    Path("environments").mkdir(exist_ok=True)
+    Path("configs").mkdir(exist_ok=True)
+    Path("configs/endpoints.toml").write_text(
+        "# OpenAI-compatible endpoints returned by `slm deploy` can be stored here.\n"
+    )
+    starter_env = Path("environments/starter_env.py")
+    if not starter_env.exists():
+        starter_env.write_text(_STARTER_ENV_PY)
+    sample = Path("configs/verifiers_grpo.toml")
+    if not sample.exists():
+        sample.write_text(
+            'model = "Qwen/Qwen3.5-4B"\n'
+            'algorithm = "grpo"\n\n'
+            "# Environment: a verifiers / Prime Hub env slug. Publish the scaffolded\n"
+            "# environments/starter_env.py with `slm env push environments/starter_env.py`\n"
+            "# (then `slm env install owner/name`) to get the slug, and set it below.\n"
+            "[environment]\n"
+            'id = "owner/name"   # a verifiers / Prime Hub env slug\n\n'
+            "[train]\n"
+            'hf_repo = "your-org/your-runs"   # HF dataset repo for adapters/checkpoints\n'
+            "steps = 150\n"
+            "lora_rank = 32\n"
+            "seeds = [0]\n\n"
+            "# Managed GPU (RTX 4090 or RTX 5090 only).\n"
+            "[gpu]\n"
+            'type = "RTX 5090"\n'
+        )
+    print(
+        "created environments/, environments/starter_env.py, configs/, "
+        "configs/verifiers_grpo.toml, configs/endpoints.toml"
+    )
+    return 0
+
+
+def cmd_models(args) -> int:
+    for row in public_model_rows():
+        print(
+            f"{row['id']}\t{row['params']}\talgos={','.join(row['algos'])}\t{row['quant']}"
+            f"\tthinking={row.get('thinking', 'none')}"
+        )
+    return 0
+
+
+def cmd_gpus(args) -> int:
+    """List GPU classes, VRAM, per-provider $/hr and live validation."""
+    from autoslm.providers import available_providers
+    from autoslm.providers.base import GPU_INFO
+    from autoslm.providers.runpod.pricing import live_rates
+
+    rates = live_rates()
+    # Cheapest live verified-datacenter offer per class (vast key + network only).
+    vast_rates: dict[str, float] = {}
+    if "vast" in available_providers():
+        try:
+            from autoslm.providers.vast.jobs import usable_offers
+
+            for offer in usable_offers(0, 0):
+                vast_rates.setdefault(offer.gpu, offer.dph_total)  # offers are price-sorted
+        except Exception as exc:
+            print(f"warning: vast offers unavailable ({exc})", file=sys.stderr)
+
+    def fmt_rate(v: float | None) -> str:
+        return f"{v:>10.2f}" if v else f"{'-':>10}"
+
+    print(f"{'gpu':<16}{'vram':>6}{'runpod$/hr':>11}{'vast$/hr':>10}  validated_on")
+    for info in sorted(GPU_INFO.values(), key=lambda g: rates.get(g.name, g.hourly_usd)):
+        runpod_rate = rates.get(info.name, info.hourly_usd) if info.enum_member else None
+        validated = ",".join(info.validated_on) or "- (needs gpu.allow_unvalidated)"
+        print(
+            f"{info.name:<16}{info.vram_gb:>5}G{fmt_rate(runpod_rate):>11}"
+            f"{fmt_rate(vast_rates.get(info.name))}  {validated}"
+        )
+    print(
+        '\nTip: omit gpu.type (or set "cheapest") to allocate the cheapest validated class\n'
+        "across providers that fits the model; gpu.provider pins runpod/vast."
+    )
+    return 0
+
+
+def cmd_env_init(args) -> int:
+    mod = args.name.replace("-", "_")
+    root = Path("environments") / mod
+    root.mkdir(parents=True, exist_ok=True)
+    # Verifiers-only: scaffold a real verifiers env whose load_environment returns a
+    # vf.Environment (here a SingleTurnEnv + Rubric over a datasets.Dataset). This is what
+    # a Hub push expects, so a freshly scaffolded env actually loads.
+    (root / f"{mod}.py").write_text(
+        f'"""Custom verifiers environment ({args.name}).\n\n'
+        "Replace the dataset and rubric with your task, then publish it to the Prime Hub\n"
+        f"with `slm env push environments/{mod}/{mod}.py` and reference it by id\n"
+        '([environment] id = "owner/name") in your config.\n'
+        "See https://github.com/PrimeIntellect-ai/verifiers for the full API.\n"
+        '"""\n\n'
+        "import verifiers as vf\n"
+        "from datasets import Dataset\n\n\n"
+        "def load_environment(**kwargs) -> vf.Environment:\n"
+        "    dataset = Dataset.from_list(\n"
+        "        [\n"
+        '            {"prompt": [{"role": "user", "content": "What is 2 + 2?"}], "answer": "4"},\n'
+        '            {"prompt": [{"role": "user", "content": "What is 3 + 5?"}], "answer": "8"},\n'
+        "        ]\n"
+        "    )\n\n"
+        "    def correct_answer(completion, answer, **_):\n"
+        '        """Reward 1.0 when the gold answer appears in the model\'s final message."""\n'
+        "        text = (\n"
+        '            completion[-1]["content"] if isinstance(completion, list) else str(completion)\n'
+        "        )\n"
+        "        return 1.0 if str(answer) in text else 0.0\n\n"
+        "    rubric = vf.Rubric(funcs=[correct_answer], weights=[1.0])\n"
+        "    return vf.SingleTurnEnv(dataset=dataset, rubric=rubric, **kwargs)\n"
+    )
+    (root / "README.md").write_text(f"# {args.name}\n\nCustom verifiers environment for AutoSLM.\n")
+    print(f"created {root}")
+    print(
+        f"publish it to the Prime Hub with `slm env push environments/{mod}/{mod}.py`, "
+        'then reference it by id ([environment] id = "owner/name") in your config.'
+    )
+    return 0
+
+
+def cmd_env_list(args) -> int:
+    from autoslm.envs.registry import list_installed_verifiers_envs
+
+    installed = list_installed_verifiers_envs()
+    if installed:
+        print("installed (verifiers / Prime Hub):")
+        for env_id in installed:
+            print(f"  {env_id}")
+    local = Path("environments")
+    if local.is_dir():
+        # Both directory envs (environments/<name>/<name>.py) and top-level single-file
+        # modules (environments/<name>.py, e.g. the `slm lab` starter env). These are local
+        # env SOURCES — publish one with `slm env push <path>` to run it on the managed
+        # service by its Hub id.
+        paths: list[str] = []
+        for p in local.iterdir():
+            if p.name.startswith("__"):
+                continue
+            if p.is_dir():
+                # `slm env init` maps a hyphenated dir to an underscored inner module file
+                # (my-env/ -> my-env/my_env.py). List that exact path, and only when it
+                # actually exists (an empty/incomplete folder isn't a publishable source).
+                stem = p.name.replace("-", "_")
+                module = p / f"{stem}.py"
+                if module.is_file():
+                    paths.append(f"environments/{p.name}/{stem}.py")
+            elif p.suffix == ".py":
+                paths.append(f"environments/{p.name}")
+        if paths:
+            print("local env sources (publish with `slm env push <path>`):")
+            for path in sorted(paths):
+                print(f"  {path}")
+    return 0
+
+
+# Prime Intellect Environments Hub pip index. Each org's wheels live under ITS OWN namespace
+# (e.g. freesolo-co/autoslm-bench -> .../freesolo-co/simple/), so derive the index from the
+# slug owner — a hardcoded `primeintellect` index 404s on any non-primeintellect env.
+PRIME_HUB_INDEX_TMPL = "https://hub.primeintellect.ai/{owner}/simple/"
+
+
+def _prime_hub_index(env_id: str) -> str:
+    owner = env_id.split("/", 1)[0] if "/" in env_id else "primeintellect"
+    return PRIME_HUB_INDEX_TMPL.format(owner=owner)
+
+
+def cmd_env_install(args) -> int:
+    import shutil
+    import subprocess
+
+    from autoslm.envs.registry import _bare_wheel_name, record_installed_env
+
+    env_id = args.env_id
+    # Managed envs are Prime Hub slugs: exactly one `/` with non-empty owner and name. A bare
+    # id (`gsm8k`) or a malformed slug can't be resolved on the Hub, so reject it up front
+    # rather than letting `prime`/pip fail with an opaque error.
+    parts = env_id.split("/")
+    if len(parts) != 2 or not parts[0] or not parts[1]:
+        print(
+            f'env id must be a Prime Hub slug "owner/name" (got {env_id!r})',
+            file=sys.stderr,
+        )
+        return 1
+    # `slm env install` is a LOCAL-client convenience: it installs the env into the client's
+    # interpreter and records it in ~/.autoslm/envs.json for local authoring/dry-run. The
+    # managed worker does NOT reinstall from this record — it installs Hub envs itself via an
+    # authenticated `prime env install` on the GPU box. A Hub slug `owner/name` maps to the pip
+    # wheel `name` on the Prime Intellect Hub index; we record that index alongside the env.
+    extras = {"extra_index_url": _prime_hub_index(env_id)}
+    if shutil.which("prime"):
+        # The `prime` CLI resolves the Hub + index itself (and is the only path that can fetch a
+        # PRIVATE Hub env — autoslm publishes envs PRIVATE).
+        cmd = ["prime", "env", "install", env_id]
+    else:
+        # The pip fallback hits the PUBLIC Hub index only; it cannot fetch PRIVATE Hub envs
+        # (the public index never serves private wheels). Be explicit instead of letting a
+        # private install fail confusingly, but still attempt pip for the public case.
+        print(
+            f"note: `prime` CLI not found; attempting a pip install of {env_id} from the "
+            "PUBLIC Hub index. PRIVATE Hub envs require the `prime` CLI — install it "
+            "(https://docs.primeintellect.ai) to install a private env."
+        )
+        installer = (
+            # `uv pip install` outside an active venv errors with "No virtual environment
+            # found"; --python targets the CLI's own interpreter so a global/pipx `slm`
+            # install still records the env.
+            ["uv", "pip", "install", "--python", sys.executable]
+            if shutil.which("uv")
+            else [sys.executable, "-m", "pip", "install"]
+        )
+        cmd = [*installer, _bare_wheel_name(env_id), "--extra-index-url", extras["extra_index_url"]]
+    print("running:", " ".join(cmd))
+    rc = subprocess.run(cmd).returncode
+    if rc != 0:
+        print("install failed")
+        return rc
+    record_installed_env(env_id, package=_bare_wheel_name(env_id), extras=extras)
+    print(f"installed {env_id}; recorded in ~/.autoslm/envs.json")
+    print(f'use it via:  [environment]\\nid = "{env_id}"')
+    return 0
+
+
+# A verifiers env packaged for the Prime Hub is a pyproject + an importable module exposing
+# load_environment(). When `slm env push` is pointed at a bare module (a single `.py`, as the
+# freesolo training agent emits, or a dir without a pyproject), we wrap it in this layout so the
+# push Just Works instead of erroring on "pyproject.toml not found".
+_ENV_PUSH_PYPROJECT = """\
+[project]
+name = "{name}"
+version = "{version}"
+description = "AutoSLM verifiers environment ({name})."
+requires-python = ">=3.10"
+dependencies = ["verifiers"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["{module}"]
+"""
+
+_PUSH_INITIAL_VERSION = "0.1.0"
+_PUSH_MAX_ATTEMPTS = 8
+_PUSH_CONFLICT_MARKERS = ("already exists", "version already", "duplicate", "conflict", "409")
+
+
+def _push_env_name(raw: str) -> str:
+    import re
+
+    name = re.sub(r"[^a-z0-9]+", "-", raw.lower()).strip("-")
+    return name or "autoslm-env"
+
+
+def _push_is_version_conflict(text: str) -> bool:
+    lowered = text.lower()
+    return any(marker in lowered for marker in _PUSH_CONFLICT_MARKERS)
+
+
+def _push_slug_from(env_dir, output: str) -> str | None:
+    import re
+
+    meta = Path(env_dir) / ".prime" / ".env-metadata.json"
+    try:
+        data = json.loads(meta.read_text())
+        owner, name = data.get("owner"), data.get("name")
+        if owner and name:
+            return f"{owner}/{name}"
+    except (OSError, json.JSONDecodeError):
+        pass
+    match = re.search(r"[Ss]uccessfully pushed\s+([A-Za-z0-9][\w.-]*/[\w.-]+)", output)
+    return match.group(1) if match else None
+
+
+def _config_env_name(config_path) -> str | None:
+    """The `name` part of a sibling autoslm.toml's `[environment] id = "owner/name"`, or None.
+
+    Used so a bare `environment.py` re-publishes under its EXISTING Hub env (minting a new
+    version) instead of deriving a fresh name from the file stem. Owner still comes from the
+    authenticated Prime account/team, so only the name part is consumed here."""
+    import tomllib
+
+    path = Path(config_path)
+    if not path.is_file():
+        return None
+    try:
+        data = tomllib.loads(path.read_text())
+    except (OSError, tomllib.TOMLDecodeError):
+        return None
+    env = data.get("environment")
+    env_id = str(env.get("id") or "").strip() if isinstance(env, dict) else ""
+    if "/" in env_id:
+        name = env_id.split("/", 1)[1].strip()
+        return name or None
+    return None
+
+
+def _config_env_name_from_dir(config_dir) -> str | None:
+    """The Hub env name declared by the sibling per-phase autoslm configs
+    (``autoslm_grpo.toml``/``autoslm_sft.toml``). Without this, pushing ``environment.py`` finds
+    no id and mints a brand-new env, so the run trains against the stale id in the configs.
+    """
+    config_dir = Path(config_dir)
+    for cfg in ("autoslm_grpo.toml", "autoslm_sft.toml"):
+        name = _config_env_name(config_dir / cfg)
+        if name:
+            return name
+    return None
+
+
+def _with_syspath_bootstrap(env_source: str) -> str:
+    """Prepend a sys.path bootstrap so a published env (run as the package __init__) can resolve
+    BARE absolute imports of its shipped sibling helpers (`import config` / `from utils import x`)
+    even without its own sys.path.insert — otherwise `prime env install`/load_environment fails
+    with ModuleNotFoundError. Inserted AFTER the module docstring and any `from __future__` imports
+    (which must stay first). Mirrors the platform hub publisher."""
+    bootstrap = (
+        "import os as _autoslm_os, sys as _autoslm_sys\n"
+        "_autoslm_sys.path.insert(0, _autoslm_os.path.dirname(__file__))\n"
+    )
+    try:
+        tree = ast.parse(env_source)
+    except SyntaxError:
+        return bootstrap + env_source
+    insert_after = 0
+    body = tree.body
+    i = 0
+    if (
+        body
+        and isinstance(body[0], ast.Expr)
+        and isinstance(getattr(body[0], "value", None), ast.Constant)
+        and isinstance(body[0].value.value, str)
+    ):
+        insert_after = body[0].end_lineno or 0
+        i = 1
+    while i < len(body) and isinstance(body[i], ast.ImportFrom) and body[i].module == "__future__":
+        insert_after = body[i].end_lineno or insert_after
+        i += 1
+    lines = env_source.splitlines(keepends=True)
+    return "".join(lines[:insert_after]) + bootstrap + "".join(lines[insert_after:])
+
+
+def _run_prime_push(env_dir, *, is_new: bool, name: str | None = None) -> int:
+    """Run `prime env push` on a packaged env dir (always PRIVATE), climbing past conflicts.
+
+    When `name` is given it is passed as `--name` so the push targets that exact Hub env."""
+    import subprocess
+
+    # Published environments are always PRIVATE — they can hold proprietary task data.
+    base = ["prime", "env", "push", "--plain", "--path", str(env_dir), "--visibility", "PRIVATE"]
+    if name:
+        base += ["--name", name]
+    # Disable prime's interactive version check so a push isn't blocked in non-interactive
+    # use (PRIME_API_KEY is inherited from the user's environment).
+    env = {**os.environ, "PRIME_DISABLE_VERSION_CHECK": "1"}
+    auto_bump = not is_new  # a re-publish must land on a fresh version
+    for _ in range(_PUSH_MAX_ATTEMPTS):
+        cmd = [*base, "--auto-bump"] if auto_bump else list(base)
+        proc = subprocess.run(cmd, capture_output=True, text=True, env=env)
+        output = f"{proc.stdout or ''}{proc.stderr or ''}"
+        if proc.stdout:
+            print(proc.stdout, end="")
+        if proc.stderr:
+            print(proc.stderr, end="")
+        if proc.returncode == 0:
+            slug = _push_slug_from(env_dir, output)
+            if slug:
+                print(f"published {slug}")
+            else:
+                # Don't report a clean success we can't confirm: the push exited 0 but we
+                # couldn't parse the owner/name id, so the env reference may be unrecorded.
+                print(
+                    "warning: `prime env push` exited 0 but no owner/name id could be parsed; "
+                    "verify the environment on the Prime Hub before training against it",
+                    file=sys.stderr,
+                )
+            return 0
+        if _push_is_version_conflict(output):
+            auto_bump = True
+            continue
+        return proc.returncode
+    print(f"push failed after {_PUSH_MAX_ATTEMPTS} version-conflict retries", file=sys.stderr)
+    return 1
+
+
+def cmd_env_push(args) -> int:
+    import shutil
+    import tempfile
+
+    if not shutil.which("prime"):
+        print("the `prime` CLI is required to publish to the Environments Hub.")
+        print("install it (https://docs.primeintellect.ai) then re-run `slm env push`.")
+        return 1
+
+    src = Path(args.path)
+    if not src.exists():
+        print(f"no such path: {src}", file=sys.stderr)
+        return 1
+
+    # A proper env directory (has a pyproject.toml) is pushed as-is; its name comes from the
+    # pyproject. Otherwise the published env name is derived from the env's path.
+    if src.is_dir() and (src / "pyproject.toml").is_file():
+        # First attempt never forces --auto-bump; the version-conflict retry enables it only
+        # when the version actually collides, so a genuine first publish keeps its version.
+        return _run_prime_push(src, is_new=True)
+
+    # Wrap a bare verifiers module (a single .py, or a one-module dir) into a Prime-compatible
+    # env package and push that. `--auto-bump` retries handle re-publishes. `data_dir` is a
+    # committed `datasets/` sibling of the module (if any); we ship it inside the package so an
+    # env that reads a `__file__`-relative data file still resolves once installed.
+    if src.is_file() and src.suffix == ".py":
+        module_source = src.read_text()
+        # Re-publish to the SAME Hub env when a sibling autoslm config names one: use its
+        # `[environment] id` name part so an edited environment.py mints a new version of the
+        # existing env instead of creating a fresh env from the file stem.
+        sibling_name = _config_env_name_from_dir(src.parent)
+        env_name = sibling_name or _push_env_name(src.stem)
+        data_dir = src.parent / "datasets"
+        # Ship the env's sibling helper modules (config.py/utils.py/...) so an environment.py that
+        # does `sys.path.insert(0, dir(__file__)); import utils` resolves once installed.
+        sibling_modules = [
+            p for p in sorted(src.parent.glob("*.py")) if p != src and not p.name.startswith("__")
+        ]
+        # A sibling config id means we're re-publishing an EXISTING Hub env: auto-bump from the
+        # first attempt so it doesn't restart at 0.1.0 and climb through version conflicts.
+        is_new = sibling_name is None
+    elif src.is_dir():
+        modules = [p for p in sorted(src.glob("*.py")) if not p.name.startswith("__")]
+        if len(modules) != 1:
+            print(
+                f"{src} has no pyproject.toml and {'no' if not modules else 'multiple'} "
+                "top-level .py module(s); point `slm env push` at the env's .py file or add a "
+                "pyproject.toml.",
+                file=sys.stderr,
+            )
+            return 1
+        module_source = modules[0].read_text()
+        env_name = _push_env_name(src.name)
+        data_dir = src / "datasets"
+        sibling_modules = []
+        is_new = True
+    else:
+        print(f"cannot publish {src}: expected a verifiers .py module or an env directory.")
+        return 1
+
+    module = env_name.replace("-", "_")
+    # A Python package name can't start with a digit, so prefix one (e.g. "2026-task").
+    if module[:1].isdigit():
+        module = f"env_{module}"
+    with tempfile.TemporaryDirectory(prefix="slm-env-push-") as tmp:
+        pkg = Path(tmp)
+        (pkg / module).mkdir()
+        (pkg / module / "__init__.py").write_text(_with_syspath_bootstrap(module_source))
+        # Ship committed sibling data inside the package dir (it lands at <module>/datasets/, so a
+        # `os.path.dirname(__file__)/datasets/...` read resolves on the worker); the whole package
+        # dir ships via `[tool.hatch.build.targets.wheel] packages = ["<module>"]`.
+        if data_dir.is_dir() and any(data_dir.iterdir()):
+            shutil.copytree(data_dir, pkg / module / "datasets")
+        for mod in sibling_modules:
+            shutil.copy2(mod, pkg / module / mod.name)
+        (pkg / "pyproject.toml").write_text(
+            _ENV_PUSH_PYPROJECT.format(name=env_name, module=module, version=_PUSH_INITIAL_VERSION)
+        )
+        (pkg / "README.md").write_text(f"# {env_name}\n\nAutoSLM verifiers environment.\n")
+        return _run_prime_push(pkg, is_new=is_new, name=env_name)
+
+
+def cmd_train(args) -> int:
+    spec = spec_from_file(
+        args.config,
+        run_id=new_run_id() if args.dry_run else None,
+        overrides=getattr(args, "overrides", None),
+        extra_configs=getattr(args, "extra_configs", None),
+    )
+    if args.dry_run:
+        # Fully local: validate the id-based config without credentials, a server, or a GPU.
+        print(
+            json.dumps(
+                {"run_id": spec.run_id, "state": "dry_run", "spec": spec.to_dict()}, indent=2
+            )
+        )
+        return 0
+    client = client_from_config()
+    status = client.create_run(spec_payload(spec))
+    run_id = status["run_id"]
+    logger.info(
+        "submitted run %s: model=%s algorithm=%s gpu=%s seeds=%s",
+        run_id,
+        spec.model,
+        spec.algorithm,
+        spec.gpu.type,
+        list(spec.train.seeds),
+    )
+    if args.background:
+        print(json.dumps(status, indent=2))
+        return 0
+    print(
+        f"run {run_id} submitted; following logs (Ctrl-C detaches, `slm attach {run_id}` resumes)",
+        file=sys.stderr,
+    )
+    return _follow_run(client, run_id)
+
+
+def _poll_logs(client: ApiClient, run_id: str, interval: float) -> str:
+    """Stream offset-paged logs until the run reaches a terminal state; return that state."""
+    offset = 0
+    while True:
+        page = client.get_logs(run_id, offset=offset)
+        if page["logs"]:
+            print(page["logs"], end="", flush=True)
+        offset = page["offset"]
+        if page["state"] in _CLI_DONE_STATES:
+            return page["state"]
+        time.sleep(interval)
+
+
+def _follow_run(client: ApiClient, run_id: str) -> int:
+    """Poll logs until the run reaches a terminal state, then print the final status."""
+    state = _poll_logs(client, run_id, interval=2.0)
+    print(json.dumps(client.get_run(run_id), indent=2))
+    return 0 if state in _OK_STATES else 1
+
+
+def cmd_status(args) -> int:
+    print(json.dumps(client_from_config().get_run(args.run_id), indent=2))
+    return 0
+
+
+def cmd_attach(args) -> int:
+    client = client_from_config()
+    return _follow_run(client, args.run_id)
+
+
+def cmd_ps(args) -> int:
+    runs = client_from_config().list_runs()
+    if not runs:
+        print("no runs yet")
+        return 0
+    print(f"{'RUN_ID':<32}  {'STATE':<11}  {'COST($)':>8}  {'GPU':<22}  MODEL")
+    for r in sorted(runs, key=lambda r: r.get("updated_at", 0), reverse=True):
+        spec = r.get("spec") or {}
+        model = spec.get("model", "")
+        remote = r.get("remote") or {}
+        # the remote handle knows what actually ran; the spec is the parse-time pick
+        provider = remote.get("provider") or (
+            "runpod" if remote else (spec.get("gpu") or {}).get("provider", "")
+        )
+        gpu = remote.get("gpu") or (spec.get("gpu") or {}).get("type", "")
+        where = f"{gpu}@{provider}" if provider else gpu
+        print(
+            f"{r['run_id']:<32}  {r['state']:<11}  {r.get('cost_usd', 0.0):>8.4f}  "
+            f"{where:<22}  {model}"
+        )
+    return 0
+
+
+def cmd_cost(args) -> int:
+    status = client_from_config().get_run(args.run_id)
+    print(
+        json.dumps(
+            {
+                "run_id": args.run_id,
+                "state": status["state"],
+                "cost_usd": status.get("cost_usd", 0.0),
+            },
+            indent=2,
+        )
+    )
+    return 0
+
+
+def cmd_cancel(args) -> int:
+    status = client_from_config().cancel_run(args.run_id)
+    print(json.dumps({"run_id": args.run_id, "state": status["state"]}, indent=2))
+    return 0
+
+
+def cmd_logs(args) -> int:
+    client = client_from_config()
+    if not args.follow:
+        print(client.get_logs(args.run_id)["logs"], end="")
+        return 0
+    _poll_logs(client, args.run_id, interval=1.0)
+    return 0
+
+
+def cmd_deploy(args) -> int:
+    dep = client_from_config().deploy(
+        args.run_id,
+        mode=args.mode,
+        idle_timeout_s=args.idle_timeout,
+        dry_run=args.dry_run,
+    )
+    print(json.dumps(dep, indent=2))
+    if dep.get("mode") == "always-on":
+        print(
+            f"note: always-on keeps a {dep.get('gpu')} warm 24/7 "
+            f"(~${dep.get('est_idle_cost_usd_per_day')}/day). Use `slm undeploy {args.run_id}` "
+            "to stop billing.",
+            file=sys.stderr,
+        )
+    return 0
+
+
+def cmd_undeploy(args) -> int:
+    print(json.dumps(client_from_config().undeploy(args.run_id), indent=2))
+    return 0
+
+
+def cmd_deployments(args) -> int:
+    rows = client_from_config().deployments()
+    if not rows:
+        print("no active deployments")
+        return 0
+    print(f"{'RUN_ID':<32}  {'MODE':<10}  {'GPU':<9}  {'$/DAY':>7}  ENDPOINT")
+    for r in rows:
+        d = r.get("deployment") or {}
+        print(
+            f"{r['run_id']:<32}  {d.get('mode', '?'):<10}  {d.get('gpu', '?'):<9}  "
+            f"{d.get('est_idle_cost_usd_per_day', 0):>7}  {d.get('endpoint_name', '')}"
+        )
+    return 0
+
+
+def cmd_chat(args) -> int:
+    resp = client_from_config().chat(
+        args.run_id,
+        messages=[{"role": "user", "content": args.message}],
+        temperature=args.temperature,
+        max_tokens=args.max_tokens,
+    )
+    print(resp["choices"][0]["message"]["content"])
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

code/autoslm/client/__init__.py

@@ -0,0 +1,14 @@
+"""HTTP client for the managed AutoSLM control plane (used by the CLI and MCP bridge)."""
+
+from .config import load_credentials, save_credentials
+from .http import ApiClient, ApiError, ClientError, client_from_config, verify_freesolo_key
+
+__all__ = [
+    "ApiClient",
+    "ApiError",
+    "ClientError",
+    "client_from_config",
+    "load_credentials",
+    "save_credentials",
+    "verify_freesolo_key",
+]

code/autoslm/client/config.py

@@ -0,0 +1,60 @@
+"""Client-side credential storage: the AutoSLM API key + control-plane URL.
+
+Stored in ``~/.autoslm/config.json`` (dir 0700, file 0600 — it holds a secret).
+Environment variables take precedence so CI/agents can inject credentials without
+touching the file: ``FREESOLO_API_KEY`` for the key, ``AUTOSLM_API_URL`` for the URL.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+from pathlib import Path
+
+DEFAULT_API_URL = "https://flash.freesolo.co"
+
+CONFIG_DIR = Path.home() / ".autoslm"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+
+
+def _read_config() -> dict:
+    try:
+        return json.loads(CONFIG_PATH.read_text())
+    except (OSError, ValueError):
+        return {}
+
+
+def load_credentials() -> tuple[str, str | None]:
+    """Resolve (api_url, api_key); the key is None when the user hasn't logged in."""
+    cfg = _read_config()
+    api_url = os.environ.get("AUTOSLM_API_URL") or cfg.get("api_url") or DEFAULT_API_URL
+    api_key = os.environ.get("FREESOLO_API_KEY") or cfg.get("api_key")
+    return api_url.rstrip("/"), api_key
+
+
+def save_credentials(api_key: str, api_url: str | None = None) -> Path:
+    """Persist the key (and optionally a non-default URL) with private permissions."""
+    cfg = _read_config()
+    cfg["api_key"] = api_key
+    if api_url:
+        # Record the plane actually authenticated against. When it's the default, drop any
+        # stored url instead of pinning it — this also clears a stale custom url from a
+        # previous custom AUTOSLM_API_URL login so later commands don't keep hitting the old host.
+        if api_url.rstrip("/") == DEFAULT_API_URL.rstrip("/"):
+            cfg.pop("api_url", None)
+        else:
+            cfg["api_url"] = api_url.rstrip("/")
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with contextlib.suppress(OSError):
+        os.chmod(CONFIG_DIR, 0o700)
+    # Create/truncate with 0600 from the start so the key is never briefly world-readable.
+    # O_NOFOLLOW (where available): refuse to follow a symlink planted at CONFIG_PATH, so
+    # saving the key can't be redirected to clobber an arbitrary file.
+    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC | getattr(os, "O_NOFOLLOW", 0)
+    fd = os.open(CONFIG_PATH, flags, 0o600)
+    with os.fdopen(fd, "w") as f:
+        json.dump(cfg, f, indent=2, sort_keys=True)
+    with contextlib.suppress(OSError):
+        os.chmod(CONFIG_PATH, 0o600)
+    return CONFIG_PATH

code/autoslm/client/http.py

@@ -0,0 +1,187 @@
+"""Stdlib HTTP client for the AutoSLM control plane (no extra dependencies).
+
+Every CLI/MCP operation maps to one method here. Server errors (FastAPI's
+``{"detail": ...}``) surface as ``ApiError`` with the server's message; connection
+problems surface as ``ClientError`` with an actionable hint.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Any
+
+from .config import load_credentials
+
+
+class ClientError(RuntimeError):
+    """Expected client-side errors (no key, unreachable server) — printed cleanly."""
+
+
+class ApiError(ClientError):
+    def __init__(self, status: int, message: str):
+        super().__init__(message)
+        self.status = status
+
+
+# Login is handled by the freesolo backend (not the autoslm control plane): `slm login`
+# verifies the user's freesolo API key here. The same key authenticates the autoslm
+# control plane, which accepts freesolo-issued keys.
+DEFAULT_FREESOLO_BASE_URL = "https://api.freesolo.co"
+FREESOLO_AUTH_VERIFY_PATH = "/api/auth/verify"
+
+
+def freesolo_base_url(override: str | None = None) -> str:
+    return (override or os.environ.get("FREESOLO_BASE_URL") or DEFAULT_FREESOLO_BASE_URL).rstrip(
+        "/"
+    )
+
+
+def _detail_from_http_error(exc: urllib.error.HTTPError) -> str:
+    """Extract the server's error message from an HTTPError body (FastAPI ``detail``)."""
+    body = exc.read()
+    try:
+        detail = json.loads(body).get("detail") or body.decode()
+    except (ValueError, AttributeError):
+        detail = body.decode(errors="replace") if body else str(exc)
+    return str(detail)
+
+
+def verify_freesolo_key(api_key: str, base_url: str | None = None) -> None:
+    """Verify a freesolo API key against the freesolo backend's ``/api/auth/verify``.
+
+    Raises :class:`ClientError`/:class:`ApiError` if the key is rejected or the backend is
+    unreachable; returns ``None`` on success. Keys are issued from the freesolo dashboard.
+    """
+    base = freesolo_base_url(base_url)
+    url = f"{base}{FREESOLO_AUTH_VERIFY_PATH}"
+    req = urllib.request.Request(
+        url,
+        method="GET",
+        headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            resp.read()
+    except urllib.error.HTTPError as exc:
+        if exc.code in (401, 403):
+            raise ClientError(
+                "freesolo rejected this API key — create or copy a valid key from your "
+                "freesolo dashboard and pass it with `slm login --api-key` (or FREESOLO_API_KEY)"
+            ) from exc
+        raise ApiError(exc.code, _detail_from_http_error(exc)) from exc
+    except urllib.error.URLError as exc:
+        raise ClientError(
+            f"cannot reach the freesolo backend at {base} ({exc.reason}); "
+            "check your network connection and FREESOLO_BASE_URL"
+        ) from exc
+
+
+class ApiClient:
+    def __init__(self, api_url: str, api_key: str | None = None, timeout: float = 60.0):
+        self.api_url = api_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: dict | None = None,
+        timeout: float | None = None,
+    ) -> Any:
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        req = urllib.request.Request(
+            f"{self.api_url}{path}",
+            method=method,
+            data=json.dumps(body).encode() if body is not None else None,
+            headers=headers,
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=timeout or self.timeout) as resp:
+                raw = resp.read()
+                return json.loads(raw) if raw else {}
+        except urllib.error.HTTPError as exc:
+            raise ApiError(exc.code, _detail_from_http_error(exc)) from exc
+        except urllib.error.URLError as exc:
+            raise ClientError(
+                f"cannot reach the AutoSLM service at {self.api_url} ({exc.reason}); "
+                "check your network connection and AUTOSLM_API_URL"
+            ) from exc
+
+    # -- identity ----------------------------------------------------------------------
+    def me(self) -> dict:
+        return self._request("GET", "/v1/me")
+
+    def health(self) -> dict:
+        return self._request("GET", "/v1/health", timeout=10.0)
+
+    # -- runs --------------------------------------------------------------------------
+    def create_run(self, spec: dict) -> dict:
+        return self._request("POST", "/v1/runs", body={"spec": spec})
+
+    def list_runs(self) -> list[dict]:
+        return self._request("GET", "/v1/runs")["runs"]
+
+    def get_run(self, run_id: str) -> dict:
+        return self._request("GET", f"/v1/runs/{run_id}")
+
+    def get_logs(self, run_id: str, offset: int = 0) -> dict:
+        return self._request("GET", f"/v1/runs/{run_id}/logs?offset={int(offset)}")
+
+    def cancel_run(self, run_id: str) -> dict:
+        return self._request("POST", f"/v1/runs/{run_id}/cancel")
+
+    # -- serving -----------------------------------------------------------------------
+    def deploy(
+        self,
+        run_id: str,
+        mode: str = "dev",
+        idle_timeout_s: int = 300,
+        dry_run: bool = False,
+    ) -> dict:
+        # always-on blocks on the server until the worker has downloaded the
+        # model/adapter and vLLM is healthy (the no-cold-start guarantee), which can
+        # take many minutes — use the serve-scale timeout, not the default 60s.
+        deploy_timeout = 30 * 60 if (mode == "always-on" and not dry_run) else None
+        return self._request(
+            "POST",
+            f"/v1/runs/{run_id}/deploy",
+            body={"mode": mode, "idle_timeout_s": idle_timeout_s, "dry_run": dry_run},
+            timeout=deploy_timeout,
+        )
+
+    def undeploy(self, run_id: str) -> dict:
+        return self._request("DELETE", f"/v1/runs/{run_id}/deploy")
+
+    def deployments(self) -> list[dict]:
+        return self._request("GET", "/v1/deployments")["deployments"]
+
+    def chat(
+        self,
+        run_id: str,
+        messages: list[dict],
+        temperature: float = 0.0,
+        max_tokens: int = 512,
+    ) -> dict:
+        # Cold starts in dev mode can take minutes; give inference a generous timeout.
+        return self._request(
+            "POST",
+            f"/v1/runs/{run_id}/chat",
+            body={"messages": messages, "temperature": temperature, "max_tokens": max_tokens},
+            timeout=30 * 60,
+        )
+
+
+def client_from_config(require_key: bool = True) -> ApiClient:
+    """Build a client from the stored credentials; fail with a clear hint when logged out."""
+    api_url, api_key = load_credentials()
+    if require_key and not api_key:
+        raise ClientError(
+            "not logged in — run `slm login` with your freesolo API key (or set FREESOLO_API_KEY)"
+        )
+    return ApiClient(api_url, api_key)

code/autoslm/client/specs.py

@@ -0,0 +1,23 @@
+"""Turn a locally validated JobSpec into the payload sent to the control plane.
+
+The one piece of client-local state a run needs is the pip requirements for installed
+verifiers / Prime Hub environments (recorded in ``~/.autoslm/envs.json`` by
+``slm env install``). The server has no access to that manifest, so the client resolves
+it here and ships it inside the spec (``environment.pip``); a value already present in
+the config (the documented escape hatch) wins.
+"""
+
+from __future__ import annotations
+
+from autoslm.spec import JobSpec
+
+
+def spec_payload(spec: JobSpec) -> dict:
+    out = spec.to_dict()
+    if not spec.environment.pip:
+        from autoslm.envs.registry import worker_pip_for_env
+
+        pip = worker_pip_for_env(spec.environment.id)
+        if pip:
+            out["environment"]["pip"] = pip
+    return out

code/autoslm/engine/__init__.py

@@ -0,0 +1,7 @@
+"""Substrate-neutral fine-tuning internals for the AutoSLM package.
+
+This subpackage holds the shared recipe, data loaders, graders, run accounting,
+and the on-GPU worker entrypoint. It has no dependency on any compute backend; the
+The RunPod provider in ``autoslm.providers.runpod`` invokes ``autoslm.engine.worker`` on the
+provisioned GPU.
+"""

code/autoslm/engine/accounting.py

@@ -0,0 +1,37 @@
+"""Cost accounting + the standard run-metrics record for AutoSLM runs.
+
+GPU cost = gpu_hours * hourly_rate (per-second billing on the selected provider —
+RunPod or Vast.ai; artifacts go via HF).
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+
+
+@dataclass
+class RunMetrics:
+    """Standard metrics record written per phase/seed."""
+
+    arm: str = "runpod"  # compute substrate
+    phase: str = ""  # "sft" | "rl"
+    seed: int = 0
+    model_id: str = ""
+    # Speed
+    wall_seconds: float = 0.0
+    setup_seconds: float = 0.0  # cold start / provisioning + model load
+    train_throughput_toks_per_s: float = 0.0
+    # Token accounting
+    train_tokens: int = 0
+    generated_tokens: int = 0  # RL: total sampled completion tokens
+    # Misc / friction. cost_usd is computed/stamped downstream by the runner from the
+    # provider's $/hr (see runner._persist_metrics), not by the worker.
+    notes: dict = field(default_factory=dict)
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self), indent=2)
+
+    def save(self, path: str):
+        with open(path, "w") as f:
+            f.write(self.to_json())

code/autoslm/engine/disaggregated.py

@@ -0,0 +1,434 @@
+"""Disaggregated (multi-GPU async) GRPO rollout: launch a ``trl vllm-serve`` rollout server on
+the inference GPUs and point the GRPO trainer at it (``vllm_mode="server"``), so generation for
+the next batch overlaps the current optimizer step instead of time-sharing one GPU.
+
+verl ref (3D-HybridEngine / flexible device mapping + async rollout):
+https://github.com/verl-project/verl
+
+The command/env builders here are PURE (no torch, no subprocess) so the launch contract is
+unit-testable on CPU; only :func:`launch_vllm_server` / :func:`wait_for_server_health` /
+:func:`detect_total_gpus` touch the system. The device split itself lives in
+:mod:`autoslm.engine.rollout_bench` (``select_rollout_split``).
+
+TRL 1.6 server-mode contract (verified against trl/scripts/vllm_serve.py + trl/generation/
+vllm_client.py): the trainer's ``VLLMClient`` waits for the server (``vllm_server_timeout``),
+opens a NCCL weight-sync group on ``vllm_group_port`` (default 51216), and on every generation
+batch ``sync_weights()`` POSTs ``/update_named_param/`` then broadcasts the (PEFT-merged) weights
+over NCCL — so weight sync is automatic; we only have to bring the server up first.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import subprocess
+import time
+import urllib.error
+import urllib.request
+
+from autoslm.engine.rollout_bench import RolloutSplit
+
+# Loopback HTTP port the rollout server binds (trainer connects via vllm_server_base_url) and the
+# NCCL weight-sync group port. Single-node (all GPUs on one rented instance) -> loopback, so no
+# firewall concerns. Both overridable for the rare port clash.
+DEFAULT_SERVER_PORT = 8000
+DEFAULT_GROUP_PORT = 51216
+# vLLM rollout server gets the whole inference card (no trainer sharing it, unlike colocate's ~0.45).
+DEFAULT_SERVER_GPU_UTIL = 0.90
+
+
+def server_port() -> int:
+    return int(os.environ.get("AUTOSLM_VLLM_SERVER_PORT", DEFAULT_SERVER_PORT))
+
+
+def group_port() -> int:
+    return int(os.environ.get("AUTOSLM_VLLM_GROUP_PORT", DEFAULT_GROUP_PORT))
+
+
+def server_base_url(port: int | None = None) -> str:
+    return f"http://127.0.0.1:{port or server_port()}"
+
+
+def detect_total_gpus(env: dict | None = None) -> int:
+    """Number of GPUs physically on this node, WITHOUT initializing a torch CUDA context.
+
+    ``torch.cuda.device_count()`` is avoided on the hot path because the disaggregated split must
+    set ``CUDA_VISIBLE_DEVICES`` on the trainer process *before* any CUDA context is created;
+    querying torch here could bind the context to all visible devices first. Prefer the explicit
+    ``AUTOSLM_GPU_COUNT`` the provisioner sets (= ``[gpu] count``), else count ``nvidia-smi -L``.
+    """
+    env = env if env is not None else os.environ
+    # GROUND TRUTH = the GPUs actually visible to THIS container (`nvidia-smi -L`, CUDA-free, honors
+    # the container's NVIDIA_VISIBLE_DEVICES). The provisioner's AUTOSLM_GPU_COUNT (= [gpu] count)
+    # is only the REQUESTED count — a provider can rent a 2-GPU offer yet expose 1 GPU to the
+    # container (observed on Vast), so trusting it would make the split assign a nonexistent device.
+    # We take the real count and only fall back to the hint when nvidia-smi is unavailable.
+    try:
+        out = subprocess.run(["nvidia-smi", "-L"], capture_output=True, text=True, timeout=20)
+        # Raw container GPU/visibility diagnostic — definitively shows what the container sees and
+        # whether an env var (CUDA_VISIBLE_DEVICES / NVIDIA_VISIBLE_DEVICES) is hiding GPUs vs the
+        # provider genuinely exposing fewer. Printed once at split time.
+        print(
+            f"[rl][disagg][diag] nvidia-smi -L:\n{out.stdout.strip()}\n"
+            f"[rl][disagg][diag] CUDA_VISIBLE_DEVICES={env.get('CUDA_VISIBLE_DEVICES')!r} "
+            f"NVIDIA_VISIBLE_DEVICES={env.get('NVIDIA_VISIBLE_DEVICES')!r} "
+            f"AUTOSLM_GPU_COUNT={env.get('AUTOSLM_GPU_COUNT')!r}"
+        )
+        lines = [ln for ln in out.stdout.splitlines() if ln.strip().startswith("GPU ")]
+        if lines:
+            real = len(lines)
+            hint = env.get("AUTOSLM_GPU_COUNT")
+            if hint and hint.isdigit() and int(hint) != real:
+                _note = (
+                    "The provider under-provisioned the node."
+                    if real < int(hint)
+                    else "The node exposes more GPUs than requested."
+                )
+                print(
+                    f"[rl][disagg] WARNING: [gpu] count requested {hint} but the container exposes "
+                    f"{real} GPU(s) (nvidia-smi) — using {real}. {_note}"
+                )
+            return real
+    except Exception:
+        pass
+    explicit = env.get("AUTOSLM_GPU_COUNT")
+    if explicit and explicit.isdigit() and int(explicit) >= 1:
+        return int(explicit)
+    try:
+        import torch
+
+        return int(torch.cuda.device_count())
+    except Exception:
+        return 1
+
+
+def _cvd(devices: tuple[int, ...]) -> str:
+    """CUDA_VISIBLE_DEVICES string from GLOBAL physical device indices."""
+    return ",".join(str(d) for d in devices)
+
+
+def trainer_cuda_visible_devices(split: RolloutSplit) -> str:
+    """The CUDA_VISIBLE_DEVICES the trainer process must use (its train devices, global indices)."""
+    return _cvd(split.train_devices)
+
+
+def build_vllm_serve_cmd(
+    model_id: str,
+    split: RolloutSplit,
+    *,
+    max_model_len: int,
+    port: int,
+    gpu_memory_util: float = DEFAULT_SERVER_GPU_UTIL,
+    quant: str = "bf16",
+    trl_bin: str | None = None,
+    trust_remote_code: bool = True,
+    enable_prefix_caching: bool = True,
+    kv_cache_dtype: str | None = None,
+    parallel: str = "tp",
+    extra: list[str] | None = None,
+) -> list[str]:
+    """The ``trl vllm-serve`` argv for the rollout server.
+
+    PARALLELISM across the inference GPUs (after CUDA_VISIBLE_DEVICES pins the server to
+    ``split.infer_devices``, those cards re-index to 0..infer_gpus-1):
+
+    * ``parallel="tp"`` (DEFAULT) -> ``--tensor_parallel_size infer_gpus``: shard ONE model across
+      the inference GPUs. For a generation-bound GRPO step the decode phase is memory-bandwidth
+      bound, so TP gives ~the aggregate HBM bandwidth of all inference cards (weights + KV split
+      across them) -> larger concurrent batches + faster decode, which is how higher inference
+      ratios (1:2, 1:3) clear the rollout bottleneck. Works for DENSE and MoE alike.
+    * ``parallel="dp"`` -> ``--data_parallel_size infer_gpus --tensor_parallel_size 1``: each
+      inference GPU is a FULL replica and the server load-balances across them. **vLLM REJECTS
+      offline data-parallel for DENSE models** ("Offline data parallel mode is not supported/useful
+      for dense models" — ParallelConfig validation), so this is ONLY usable for the MoE model
+      (Qwen3.6-35B-A3B), where DP shards experts. Do NOT default to it: every dense model in the
+      catalog (MiniCPM, the Qwen3.5 dense line) must use TP.
+
+    ``max_model_len`` bounds the KV cache to the GRPO need (prompt+completion) so the server starts
+    on a consumer card instead of sizing for the model's full context.
+
+    Only flags that ``trl vllm-serve``'s ScriptArguments actually defines are emitted (verified
+    against trl/scripts/vllm_serve.py): model, tensor_parallel_size, data_parallel_size, host, port,
+    gpu_memory_utilization, max_model_len, enable_prefix_caching, trust_remote_code. The CLI has NO
+    quantization/load_format option, so a ``4bit-qlora`` model is served bf16/auto on its OWN
+    inference card (in disaggregated mode the inference GPU holds ONLY the rollout, not a colocated
+    trainer, so the full-precision weights fit a big enough card). The trainer still loads the base
+    4-bit (its model_init_kwargs are independent); TRL merges the LoRA into bf16 before each weight
+    sync, so trainer-4-bit + server-bf16 stays consistent. ``quant`` is accepted for signature
+    stability / sizing notes but does not change the server command.
+    """
+    bin_ = trl_bin or os.environ.get("AUTOSLM_TRL_BIN", "trl")
+    if parallel == "dp":
+        # DP replicas: server load-balances generation across infer_gpus full copies. vLLM ONLY
+        # allows offline DP for MoE models -> reserve this for the 35B-A3B; dense models must use TP.
+        par_flags = [
+            "--data_parallel_size",
+            str(split.infer_gpus),
+            "--tensor_parallel_size",
+            "1",
+        ]
+    else:
+        # TP (DEFAULT): shard one model across the inference GPUs -> aggregate HBM bandwidth for a
+        # faster, larger-batch decode (the win for higher ratios on a generation-bound step).
+        par_flags = ["--tensor_parallel_size", str(split.infer_gpus)]
+    cmd = [
+        bin_,
+        "vllm-serve",
+        "--model",
+        model_id,
+        *par_flags,
+        "--host",
+        "127.0.0.1",
+        "--port",
+        str(port),
+        "--gpu_memory_utilization",
+        str(gpu_memory_util),
+        "--max_model_len",
+        str(max_model_len),
+    ]
+    if trust_remote_code:
+        cmd += ["--trust_remote_code", "true"]
+    # verl-validated rollout-engine levers (mirror the colocate path): PREFIX CACHING reuses the
+    # shared GRPO prompt-prefix KV across a group's completions (the dominant rollout win); fp8 KV
+    # CACHE (Ada/Hopper/Blackwell, compute capability >= 8.9) ~halves the KV pool so a bigger
+    # generation batch fits the inference card. CUDA graphs are on by default (enforce_eager unset).
+    if enable_prefix_caching:
+        cmd += ["--enable_prefix_caching", "true"]
+    if kv_cache_dtype:
+        cmd += ["--kv_cache_dtype", kv_cache_dtype]
+    if extra:
+        cmd += list(extra)
+    return cmd
+
+
+# The flags `trl vllm-serve` (TRL 1.6 ScriptArguments) actually accepts. HfArgumentParser REJECTS
+# any unknown --flag, failing server launch — so build_vllm_serve_cmd must only emit these (see the
+# allowlist test). Mirrors trl/scripts/vllm_serve.py:ScriptArguments.
+TRL_VLLM_SERVE_FLAGS = frozenset(
+    {
+        "--model",
+        "--revision",
+        "--tensor_parallel_size",
+        "--data_parallel_size",
+        "--host",
+        "--port",
+        "--gpu_memory_utilization",
+        "--dtype",
+        "--max_model_len",
+        "--enable_prefix_caching",
+        "--enforce_eager",
+        "--kv_cache_dtype",
+        "--trust_remote_code",
+        "--log_level",
+        "--vllm_model_impl",
+        "--distributed_executor_backend",
+        "--speculative_config",
+    }
+)
+
+
+def build_accelerate_launch_cmd(
+    split: RolloutSplit,
+    *,
+    worker_module: str = "autoslm.engine.worker",
+    mixed_precision: str = "bf16",
+    use_fsdp: bool = True,
+    python_bin: str | None = None,
+) -> list[str]:
+    """``accelerate launch`` argv that runs the GRPO trainer across the TRAIN devices (FSDP).
+
+    For a train_gpus>1 ratio (2:1, 3:1, 2:2) the trainer must be a *distributed* process group, not
+    a single process spanning many GPUs (that silently becomes nn.DataParallel, which TRL's
+    weight-sync gather does not support). The disaggregated launcher brings the vLLM rollout server
+    up on the inference GPUs first, then re-execs the worker's RL phase under this command so
+    ``accelerate`` shards the trainer across ``split.train_gpus`` with FSDP and the trainer connects
+    to the already-running server (``AUTOSLM_RL_TRAINER_ONLY=1`` in the child env).
+
+    ``--gpu_ids`` pins the child group to the GLOBAL train device indices (so it never touches the
+    inference card), and ``--num_processes`` == train_gpus (one rank per train GPU). FSDP (vs DDP)
+    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.
+    """
+    cmd = [
+        "accelerate",
+        "launch",
+        "--num_machines",
+        "1",
+        "--num_processes",
+        str(split.train_gpus),
+        "--gpu_ids",
+        _cvd(split.train_devices),
+        "--mixed_precision",
+        mixed_precision,
+        "--dynamo_backend",
+        "no",
+    ]
+    if use_fsdp:
+        # FSDP full-shard with transformer auto-wrap: shards params+grads+optimizer across ranks so
+        # the trainer scales past one card. CPU-offload off (the train GPUs have room; offload would
+        # tank throughput). NB: `--use_fsdp` already implies multi-GPU — accelerate REJECTS
+        # `--multi_gpu` alongside it ("You can only use one of --cpu/--multi_gpu/--use_fsdp ..."), so
+        # 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",
+            "SHARD_GRAD_OP",
+            "--fsdp_auto_wrap_policy",
+            "TRANSFORMER_BASED_WRAP",
+            # 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",
+        ]
+    else:
+        # Plain DDP across the train GPUs (replicate, no sharding) — needs the explicit --multi_gpu.
+        cmd.insert(2, "--multi_gpu")
+    cmd += ["-m", worker_module]
+    return cmd
+
+
+def is_main_rank(env: dict | None = None) -> bool:
+    """True on the rank that must write artifacts (adapter/metrics/DONE/upload).
+
+    Single-process paths (colocate, train_gpus==1) set no RANK -> "0" -> main, so existing behavior
+    is unchanged; under ``accelerate launch`` only RANK 0 writes, avoiding N concurrent HF uploads.
+    """
+    env = env if env is not None else os.environ
+    return str(env.get("RANK", "0")) == "0"
+
+
+def trainer_only_mode(env: dict | None = None) -> bool:
+    """True inside the accelerate-launched trainer child (server already up; skip the launcher)."""
+    env = env if env is not None else os.environ
+    return str(env.get("AUTOSLM_RL_TRAINER_ONLY", "")) in ("1", "true", "True")
+
+
+def server_subprocess_env(base_env: dict, split: RolloutSplit) -> dict:
+    """Env for the vllm-serve subprocess: pin it to the GLOBAL inference device indices.
+
+    Built from a COPY so the parent (trainer) can independently set its own CUDA_VISIBLE_DEVICES to
+    the train devices without affecting the already-launched server. The group port is exported so
+    the server's weight-sync extension and the trainer's client agree on the NCCL rendezvous.
+    """
+    env = dict(base_env)
+    env["CUDA_VISIBLE_DEVICES"] = _cvd(split.infer_devices)
+    env.setdefault("AUTOSLM_VLLM_GROUP_PORT", str(group_port()))
+    # Force vLLM's worker/inspection subprocesses to SPAWN (not fork). `trl vllm-serve` runs its
+    # llm_worker as a multiprocessing.Process and vLLM forks a further subprocess to inspect the
+    # model architecture; a fork after the parent has touched CUDA/NVML corrupts the NVML handle in
+    # the child -> `NVMLError_InvalidArgument` during ModelConfig inspection ("architectures failed
+    # to be inspected"). Spawn gives each child a clean CUDA/NVML state. (The colocate path is
+    # in-process so it never hit this.)
+    env.setdefault("VLLM_WORKER_MULTIPROC_METHOD", "spawn")
+    return env
+
+
+def _server_log_tail(log_path: str | None, n: int = 60) -> str:
+    """Last ``n`` lines of the rollout server's log (its model-load crash lives here). The TRL
+    server only binds its HTTP port AFTER its llm_worker child loads the model + reports ready
+    (trl/scripts/vllm_serve.py lifespan), so a load crash shows as 'connection refused' on the
+    port while the real error is ONLY in this log — surface it so error_rl.txt is diagnosable."""
+    if not log_path:
+        return ""
+    try:
+        with open(log_path, errors="replace") as f:
+            lines = f.read().splitlines()
+        return "\n".join(lines[-n:])
+    except Exception as e:
+        return f"(server log unreadable: {e})"
+
+
+def wait_for_server_health(
+    port: int,
+    *,
+    timeout: float,
+    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').
+
+    ``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:
+                    return
+        except urllib.error.HTTPError as e:
+            # Only a 2xx on /health/ means ready. vLLM routes (and returns 4xx on) endpoints while
+            # the engine is still loading, so a 4xx is NOT healthy — keep polling until a real 200
+            # (or the timeout / a dead subprocess), rather than handing the trainer a server that
+            # then fails at the first generation.
+            last = f"HTTP {e.code}"
+        except Exception as e:  # connection refused while still loading
+            last = str(e)[:80]
+        time.sleep(interval)
+    raise TimeoutError(
+        f"vllm-serve not healthy after {timeout:.0f}s (last: {last}).\n"
+        f"--- vllm-serve log tail ---\n{_server_log_tail(log_path)}"
+    )
+
+
+def launch_vllm_server(
+    cmd: list[str], env: dict, *, log_path: str = "/tmp/vllm_serve.log"
+) -> subprocess.Popen:
+    """Start the rollout server subprocess, streaming its stdout/stderr to ``log_path`` (so a
+    server-side load/OOM is recoverable from the run log on a rented node)."""
+    log = open(log_path, "wb")  # noqa: SIM115 — handle lives with the long-running subprocess
+    print(f"[rl][disagg] launching rollout server: {' '.join(cmd)}")
+    print(f"[rl][disagg] server CUDA_VISIBLE_DEVICES={env.get('CUDA_VISIBLE_DEVICES')} log={log_path}")
+    return subprocess.Popen(cmd, env=env, stdout=log, stderr=subprocess.STDOUT)
+
+
+def terminate_server(proc: subprocess.Popen | None, *, timeout: float = 15.0) -> None:
+    """Best-effort shutdown of the rollout server after training (free its GPU + port)."""
+    if proc is None or proc.poll() is not None:
+        return
+    try:
+        proc.terminate()
+        proc.wait(timeout=timeout)
+    except Exception:
+        with contextlib.suppress(Exception):
+            proc.kill()

code/autoslm/engine/multiturn_rollout.py

@@ -0,0 +1,266 @@
+"""Multi-turn / tool GRPO rollout for TRL's experimental ``rollout_func`` (colocate vLLM).
+
+TRL's ``GRPOTrainer`` generates a single assistant turn per prompt, which cannot drive a
+verifiers ``MultiTurnEnv`` / ``ToolEnv`` turn loop (model turn -> env reply -> ...). This
+module supplies a ``rollout_func`` that:
+
+  * drives the env's turn loop via the adapter helpers (``new_rollout_state`` /
+    ``record_model_turn`` / ``env_reply`` / ``rollout_done``), so the *env* owns tool
+    execution, ``StatefulToolEnv`` state threading, and any simulated-user turns;
+  * returns the FULL interleaved token sequence as ``completion_ids`` together with an
+    ``env_mask`` that marks model-generated tokens (``1``, trained) vs tool/env tokens
+    (``0``, masked out of the loss). ``env_mask`` is TRL's documented mechanism for
+    multi-turn credit assignment (it is treated internally as the tool mask), so only the
+    policy's own tokens get advantage while the env tokens still provide context for the
+    forward pass;
+  * scores each rollout with the env's weighted rubric (``reward_from_messages``) and returns
+    it as an extra field consumed by a pass-through ``reward_func``.
+
+Token alignment assumes a **prefix-preserving** chat template: appending a message must not
+retokenize earlier turns (the same assumption TRL's native tool loop documents; auto-patched
+for Qwen3 / DeepSeek-V3). The env segment between two model turns is taken as the suffix of a
+full re-render; if the prefix invariant is violated the rollout raises (fails loudly) rather
+than mis-masking model vs env tokens and silently mistraining.
+
+The core (:func:`rollout_one`) is pure Python and takes injected ``render``/``generate``
+callables so it can be unit-tested without a GPU/tokenizer; :func:`build_rollout_func` wires
+the real tokenizer + the colocate vLLM engine into it at runtime.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from typing import TypedDict
+
+
+class RolloutResult(TypedDict):
+    """Token-aligned fields returned per rollout for TRL's ``rollout_func``."""
+
+    prompt_ids: list[int]
+    completion_ids: list[int]
+    logprobs: list[float]
+    env_mask: list[int]
+    reward: float
+
+
+# Field names shared between a single RolloutResult and the batched dict-of-lists that
+# build_rollout_func returns. Kept as a plain tuple (not RolloutResult.__annotations__) so
+# the batch accumulator's key source isn't a single-rollout type whose value types (float,
+# list[int], ...) deliberately differ from the accumulator's list-of-those.
+_ROLLOUT_FIELDS: tuple[str, ...] = (
+    "prompt_ids",
+    "completion_ids",
+    "logprobs",
+    "env_mask",
+    "reward",
+)
+
+
+def _prompt_key(prompt) -> str:
+    """Stable key for mapping a dataset ``prompt`` value back to its example row."""
+    try:
+        return json.dumps(prompt, sort_keys=True, default=str)
+    except (TypeError, ValueError):
+        return str(prompt)
+
+
+def build_examples_index(rows: list[dict], prompt_of: Callable[[dict], object]) -> dict:
+    """Map each row's rendered ``prompt`` value to the example row (for reward/answer lookup).
+
+    Collisions (two rows producing the same prompt) keep the last row and are reported by the
+    caller via :func:`index_collisions`; duplicates are rare in training data and only affect
+    which ``answer``/``info`` a shared prompt scores against.
+    """
+    return {_prompt_key(prompt_of(r)): r for r in rows}
+
+
+def index_collisions(rows: list[dict], prompt_of: Callable[[dict], object]) -> int:
+    """Number of rows dropped by prompt-key collisions in :func:`build_examples_index`."""
+    return len(rows) - len({_prompt_key(prompt_of(r)) for r in rows})
+
+
+def rollout_one(
+    *,
+    example: dict,
+    active_env,
+    render: Callable[[list, bool], list[int]],
+    generate: Callable[[list, int], tuple[list[int], list[float], str]],
+    max_turns: int,
+    per_turn_max_tokens: int,
+    engine_max_len: int | None = None,
+    on_warn: Callable[[str], None] | None = None,
+) -> RolloutResult:
+    """Run one multi-turn/tool rollout and return TRL ``rollout_func`` fields for it.
+
+    Args:
+        example: the dataset row (carries ``answer``/``info`` for the rubric).
+        active_env: the ``VerifiersEnvironment`` adapter (drives the turn loop + scoring).
+        render: ``render(messages, add_generation_prompt) -> token_ids`` (chat template).
+        generate: ``generate(prefix_token_ids, max_tokens) -> (token_ids, token_logprobs,
+            text)`` for one sampled assistant turn (model tokens + sampling logprobs + text);
+            ``max_tokens`` bounds that turn so it can't overflow the engine context.
+        max_turns: hard cap on model turns (defense against a non-terminating env).
+
+    Returns a dict with ``prompt_ids``, ``completion_ids``, ``logprobs``, ``env_mask`` (all
+    token-aligned) and the scalar ``reward`` for this rollout.
+    """
+    state = active_env.new_rollout_state(example)
+    messages = [dict(m) for m in state["prompt"]]
+    prompt_ids = render(messages, True)
+    cur_ids = list(prompt_ids)  # invariant: cur_ids == prompt_ids + completion_ids so far
+    # Per-rollout completion cap so prompt + accumulated completion never exceeds the colocate
+    # engine's context (which would overflow the next generate()); leave a small margin.
+    token_budget = (engine_max_len - len(prompt_ids) - 8) if engine_max_len else None
+    completion_ids: list[int] = []
+    logprobs: list[float] = []
+    env_mask: list[int] = []
+
+    turns = 0
+    while True:
+        # Bound THIS turn's generation by the remaining engine headroom so even a single
+        # generate() can't push prompt+completion past the context (the cap below stops the
+        # loop AFTER a turn; this stops the turn itself from overflowing).
+        max_new = per_turn_max_tokens
+        if token_budget is not None:
+            remaining = token_budget - len(completion_ids)
+            if remaining <= 0:
+                break
+            max_new = min(max_new, remaining)
+        asst_ids, asst_lp, text = generate(cur_ids, max_new)
+        completion_ids.extend(asst_ids)
+        logprobs.extend(asst_lp)
+        env_mask.extend([1] * len(asst_ids))
+        cur_ids.extend(asst_ids)
+        active_env.record_model_turn(state, text)
+        messages.append({"role": "assistant", "content": text})
+        turns += 1
+
+        if token_budget is not None and len(completion_ids) >= token_budget:
+            break
+        if turns >= max_turns or active_env.rollout_done(state, max_turns):
+            break
+        env_msgs = active_env.env_reply(messages, state)
+        if not env_msgs:
+            break
+        messages.extend(env_msgs)
+
+        # Env-segment tokens = the suffix added by re-rendering the conversation (with the next
+        # generation prompt) beyond what we already have. Masked (0) — they are not the
+        # policy's tokens — but kept in completion_ids so the next turn conditions on them. This
+        # REQUIRES a prefix-preserving template (appending a message must not retokenize earlier
+        # turns); otherwise the model/env token boundary is wrong and the loss mask is garbage —
+        # so fail loudly rather than silently mis-train.
+        new_ids = render(messages, True)
+        if new_ids[: len(cur_ids)] != cur_ids:
+            msg = (
+                "multi-turn rollout requires a prefix-preserving chat template (appending a "
+                "message must not retokenize earlier turns); this model's template is not. Use "
+                "a single-turn/tool env, or a model whose template is prefix-preserving."
+            )
+            if on_warn:
+                on_warn(msg)
+            raise ValueError(msg)
+        env_seg = new_ids[len(cur_ids) :]
+        completion_ids.extend(env_seg)
+        logprobs.extend([0.0] * len(env_seg))
+        env_mask.extend([0] * len(env_seg))
+        cur_ids = list(new_ids)
+
+    # Score with the ACTUAL rollout state (not a fresh one) so reward funcs see the tool/env
+    # state the rollout accumulated. state["completion"] holds the full transcript.
+    reward = active_env.reward("", example, state)
+    return {
+        "prompt_ids": prompt_ids,
+        "completion_ids": completion_ids,
+        "logprobs": logprobs,
+        "env_mask": env_mask,
+        "reward": float(reward),
+    }
+
+
+def build_rollout_func(
+    *,
+    active_env,
+    tok,
+    examples_by_key: dict,
+    max_completion: int,
+    max_turns: int,
+    temperature: float,
+    top_p: float,
+    stop: list[str] | None,
+    thinking: bool,
+    engine_max_len: int | None = None,
+    num_generations_attr: str = "num_generations",
+):
+    """Return a TRL ``rollout_func`` closure that drives ``active_env`` on the colocate engine.
+
+    The closure reaches the in-process vLLM engine through ``trainer.vllm_generation.llm`` and
+    samples each assistant turn with per-token logprobs; ``num_generations`` rollouts are
+    produced per prompt (TRL requires the flattened per-prompt grouping).
+    """
+    from vllm import SamplingParams  # gpu-only; imported lazily so the module loads on CPU
+
+    def render(messages: list, add_generation_prompt: bool) -> list[int]:
+        # Render to text first, then tokenize — apply_chat_template(tokenize=True) return
+        # shape varies by tokenizer; tok(text).input_ids is reliably a flat list[int]
+        # (matches the single-turn render_prompt path). add_special_tokens=False because the
+        # template already emits the special tokens.
+        text = tok.apply_chat_template(
+            messages,
+            add_generation_prompt=add_generation_prompt,
+            tokenize=False,
+            enable_thinking=thinking,
+        )
+        return [int(t) for t in tok(text, add_special_tokens=False).input_ids]
+
+    def rollout_func(prompts, trainer):
+        engine = trainer.vllm_generation.llm
+        num_gen = int(getattr(trainer, num_generations_attr, 1) or 1)
+
+        def generate(prefix_ids: list[int], max_tokens: int):
+            sp = SamplingParams(
+                max_tokens=max(1, int(max_tokens)),
+                temperature=temperature,
+                top_p=top_p,
+                logprobs=1,  # include the sampled token's logprob at each position
+                stop=list(stop) if stop else None,
+            )
+            # vLLM's LLM.generate takes prompts (TokensPrompt-style dicts), not a
+            # `prompt_token_ids` kwarg — pass pre-tokenized ids as {"prompt_token_ids": ...}.
+            out = engine.generate(
+                [{"prompt_token_ids": list(prefix_ids)}],
+                sampling_params=sp,
+                use_tqdm=False,
+            )
+            comp = out[0].outputs[0]
+            token_ids = list(comp.token_ids)
+            # comp.logprobs is a list (per position) of {token_id: Logprob}; pull the sampled
+            # token's logprob at each position.
+            lps: list[float] = []
+            for pos, tid in enumerate(token_ids):
+                entry = (comp.logprobs or [])[pos] if comp.logprobs else None
+                lp = entry.get(tid) if entry else None
+                lps.append(float(getattr(lp, "logprob", 0.0)) if lp is not None else 0.0)
+            return token_ids, lps, comp.text
+
+        # One accumulator list per rollout field (batched dict-of-lists across all rollouts).
+        out: dict[str, list] = {k: [] for k in _ROLLOUT_FIELDS}
+        for prompt in prompts:
+            example = examples_by_key.get(_prompt_key(prompt), {"prompt": prompt})
+            for _ in range(num_gen):
+                r = rollout_one(
+                    example=example,
+                    active_env=active_env,
+                    render=render,
+                    generate=generate,
+                    max_turns=max_turns,
+                    per_turn_max_tokens=max_completion,
+                    engine_max_len=engine_max_len,
+                    on_warn=print,
+                )
+                for k in out:
+                    out[k].append(r[k])
+        return out
+
+    return rollout_func

code/autoslm/engine/recipe.py

@@ -0,0 +1,91 @@
+"""Frozen, shared AutoSLM fine-tuning recipe.
+
+Single source of truth for the default fine-tuning hyperparameters: base model,
+tokenizer, data, LoRA config, optimization, token budget, and decoding.
+Per-run TOML configs (parsed into a ``JobSpec``) override the relevant fields.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+
+# ----------------------------------------------------------------------------
+# Model identity
+# ----------------------------------------------------------------------------
+# Recipe fallback base model. Model selection precedence on the worker is
+# JobSpec.model > env BENCH_HF_MODEL > this recipe default; worker.py resolves
+# JOB_SPEC.model first and only falls back to RECIPE.hf_model_id. The RunPod launcher
+# sets BENCH_HF_MODEL from the spec; Vast carries the model via the full JobSpec
+# (JOB_SPEC.model), which the worker resolves before this fallback. This literal is the
+# last-resort default when neither is present.
+# Keep it in sync with catalog.DEFAULT_MODEL (a proven dense text-only instruction model
+# that loads on the current worker stack: transformers 5.x / TRL 1.x / vLLM 0.19.x; the
+# natively-multimodal Qwen3.5/3.6 checkpoints are also catalog'd, trained/served text-only).
+HF_MODEL_ID = os.environ.get("BENCH_HF_MODEL", "Qwen/Qwen3.5-4B")  # catalog DEFAULT_MODEL
+
+
+# ----------------------------------------------------------------------------
+# LoRA (rank is the main user-controllable knob)
+# ----------------------------------------------------------------------------
+@dataclass(frozen=True)
+class LoRAConfig:
+    rank: int = 32
+    alpha: int = 64
+    dropout: float = 0.0
+    # The worker adapts all linear projections, set via the LORA_TARGETS env var
+    # (default "all-linear" — see engine.worker); `rank`/`alpha` are the main
+    # user-controllable knobs here.
+
+
+# ----------------------------------------------------------------------------
+# SFT (Phase 1)
+# ----------------------------------------------------------------------------
+@dataclass(frozen=True)
+class SFTConfig:
+    max_seq_len: int = 1024
+    # Thinking-mode sequence cap: <think> traces in targets need headroom. A deliberate
+    # consumer-GPU compromise (SFT cost/VRAM scales with sequence length).
+    max_seq_len_thinking: int = 2048
+    learning_rate: float = 1e-4
+    warmup_frac: float = 0.03
+    # Effective batch = per_device_batch * grad_accum (Arm A) / batch of datums (Arm B)
+    effective_batch: int = 32
+    num_epochs: int = 2
+
+
+# ----------------------------------------------------------------------------
+# RL / GRPO (Phase 2)
+# ----------------------------------------------------------------------------
+@dataclass(frozen=True)
+class RLConfig:
+    learning_rate: float = 1e-5
+    # Default engine prompt budget. 512 was too small for real envs with non-trivial system
+    # prompts (e.g. a schema/instructions block + the user query), which made every prompt
+    # overflow before training started. 2048 fits typical instruction prompts; the run's
+    # [train].max_length sets the engine length explicitly when it needs more/less.
+    max_prompt_len: int = 2048
+    max_completion_len: int = 320
+    # Thinking-mode completion budget: <think> blocks consume most of it (phase 0
+    # showed 320 is hopeless — every completion hit the cap). 1536 is a consumer-GPU
+    # compromise (KV cache + rollout cost scale linearly with completion length, ~5x
+    # tokens/step vs non-thinking); the run's [train].max_tokens overrides it explicitly.
+    max_completion_len_thinking: int = 1536
+    prompts_per_step: int = 64
+    group_size: int = 8  # G completions per prompt
+    num_steps: int = 150  # overridable per-run via the TOML `train.steps`
+    sampling_temperature: float = 1.0  # on-policy sampling for rollouts
+    sampling_top_p: float = 1.0
+
+
+@dataclass(frozen=True)
+class Recipe:
+    """The complete shared recipe."""
+
+    hf_model_id: str = HF_MODEL_ID
+    lora: LoRAConfig = field(default_factory=LoRAConfig)
+    sft: SFTConfig = field(default_factory=SFTConfig)
+    rl: RLConfig = field(default_factory=RLConfig)
+
+
+RECIPE = Recipe()

code/autoslm/engine/rollout_bench.py

@@ -0,0 +1,125 @@
+"""Trainer:inference GPU-split selection + the ratio-benchmark grid for disaggregated GRPO.
+
+Pure logic (no torch / no provisioning): given a node's GPU ``count`` and the number of
+``inference_gpus`` to dedicate to the vLLM rollout server, decide the rollout MODE and the
+``CUDA_VISIBLE_DEVICES`` split for trainer vs inference. ``ratio_grid`` enumerates the *reasonable*
+trainer:inference splits within a node for the benchmark sweep (colocate, 1:1, 1:2, 2:1, ...) —
+deliberately excluding absurd splits (e.g. 7 train : 1 infer).
+
+The live worker (``engine.worker.run_rl``) consumes :func:`select_rollout_split` to launch
+``trl vllm-serve`` on the inference devices and the FSDP trainer on the rest; this module stays
+GPU-free so the split math + grid are unit-testable on CPU.
+
+verl ref (3D-HybridEngine / flexible device mapping): https://github.com/verl-project/verl
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# Don't dedicate more than this fraction of a node to one side — keeps the sweep to "reasonable"
+# splits. A 3:1 (or 1:3) imbalance is the practical ceiling; beyond that the small side starves.
+_MAX_RATIO = 3
+
+
+@dataclass(frozen=True)
+class RolloutSplit:
+    """How a node's GPUs are partitioned for one GRPO config."""
+
+    mode: str  # "colocate" (vLLM shares the trainer GPU) | "disaggregated" (separate infer GPUs)
+    total_gpus: int
+    train_gpus: int
+    infer_gpus: int
+    train_devices: tuple[int, ...]
+    infer_devices: tuple[int, ...]
+
+    @property
+    def label(self) -> str:
+        if self.mode == "colocate":
+            return "colocate"
+        return f"{self.train_gpus}:{self.infer_gpus}"
+
+
+def select_rollout_split(total_gpus: int, inference_gpus: int) -> RolloutSplit:
+    """Partition ``total_gpus`` into a trainer set + an inference (vLLM-server) set.
+
+    ``inference_gpus == 0`` → colocate (the current single-process TRL path; vLLM shares device 0).
+    ``inference_gpus > 0``  → disaggregated: the FIRST ``inference_gpus`` devices serve vLLM, the
+    rest train. The vLLM server is pinned to device 0 deliberately: vLLM's model-inspection probe
+    queries NVML by the *physical* device id of its first visible card, and NVML (which respects
+    CUDA_VISIBLE_DEVICES) only exposes the restricted set — so a server pinned to a non-zero device
+    (e.g. CVD="1") makes vLLM query NVML index 1 in a 1-device view → NVMLError_InvalidArgument
+    ("architectures failed to be inspected"). Putting inference on device 0 keeps that query at the
+    always-valid index 0. The trainer (in-process torch, no vLLM inspection) handles a non-zero CVD
+    fine. Raises on an impossible split so a bad config fails fast at setup rather than mid-run.
+    """
+    if total_gpus < 1:
+        raise ValueError(f"total_gpus must be >= 1, got {total_gpus}")
+    if inference_gpus < 0:
+        raise ValueError(f"inference_gpus must be >= 0, got {inference_gpus}")
+    if inference_gpus == 0:
+        return RolloutSplit(
+            mode="colocate",
+            total_gpus=total_gpus,
+            train_gpus=total_gpus,
+            infer_gpus=0,
+            train_devices=tuple(range(total_gpus)),
+            infer_devices=(),
+        )
+    if inference_gpus >= total_gpus:
+        raise ValueError(
+            f"inference_gpus ({inference_gpus}) must be < total_gpus ({total_gpus}); "
+            "at least one GPU must train"
+        )
+    train_gpus = total_gpus - inference_gpus
+    return RolloutSplit(
+        mode="disaggregated",
+        total_gpus=total_gpus,
+        train_gpus=train_gpus,
+        infer_gpus=inference_gpus,
+        # Inference on the FIRST devices (server gets device 0 → NVML index 0, always valid);
+        # trainer on the rest.
+        train_devices=tuple(range(inference_gpus, total_gpus)),
+        infer_devices=tuple(range(inference_gpus)),
+    )
+
+
+def validate_disaggregated_requirement(
+    *, requires_disaggregated: bool, algorithm: str, inference_gpus: int
+) -> None:
+    """Reject colocated GRPO for a model that needs the disaggregated path.
+
+    A ``requires_disaggregated`` model (e.g. Qwen3.6-35B-A3B) OOMs when the trainer and the vLLM
+    rollout share one GPU, so its GRPO runs must dedicate inference GPUs (``inference_gpus>0`` on a
+    multi-GPU node). SFT has no rollout engine and is unaffected. Raising here fails a bad config at
+    submit instead of mid-run on a paid GPU.
+    """
+    if requires_disaggregated and (algorithm or "").lower() == "grpo" and inference_gpus <= 0:
+        raise ValueError(
+            "this model requires the disaggregated GRPO path: set [train].inference_gpus>0 on a "
+            "multi-GPU node ([gpu] count = train_gpus + inference_gpus). Colocated GRPO OOMs for it."
+        )
+
+
+def ratio_grid(max_gpus: int = 4) -> list[RolloutSplit]:
+    """The reasonable (train:infer) configs to benchmark, in a sensible order.
+
+    Always starts with ``colocate`` (1 GPU, the baseline), then the 2..``max_gpus`` node splits with
+    both sides >= 1 and the imbalance bounded by ``_MAX_RATIO`` (so no 7:1). Ordered by total GPUs,
+    then by infer count, so the table reads colocate → 1:1 → 1:2 → 2:1 → 3:1 → ...
+    """
+    grid = [select_rollout_split(1, 0)]  # colocate baseline
+    seen = {grid[0].label}
+    for total in range(2, max_gpus + 1):
+        for infer in range(1, total):
+            train = total - infer
+            if max(train, infer) / min(train, infer) > _MAX_RATIO:
+                continue
+            split = select_rollout_split(total, infer)
+            if split.label not in seen:
+                seen.add(split.label)
+                grid.append(split)
+    # colocate first, then by (total gpus, infer gpus) for a readable sweep
+    head, tail = grid[0], grid[1:]
+    tail.sort(key=lambda s: (s.total_gpus, s.infer_gpus))
+    return [head, *tail]

code/autoslm/engine/verl_runner.py

@@ -0,0 +1,695 @@
+"""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")
+    # 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/vram.py

@@ -0,0 +1,323 @@
+"""Coarse VRAM-fit estimation for one-consumer-GPU LoRA jobs.
+
+Used by the open-model policy (``model_policy = "allow"``) to sanity-check that an
+unlisted HF model can plausibly run on the requested GPU before provisioning it.
+
+These are deliberately coarse heuristics (documented ±20%): they exist to catch
+*provably impossible* configurations (70B bf16 on a 24 GB card) and to warn on tight
+fits — not to guarantee success. Calibrated against the measured catalog entries
+(Qwen3-0.6B/4B/8B, Qwen3.5 dense).
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import re
+from dataclasses import dataclass
+
+
+def _gpu_vram_table() -> dict[str, int]:
+    try:
+        from autoslm.providers.base import GPU_INFO
+
+        return {name: info.vram_gb for name, info in GPU_INFO.items()}
+    except Exception:
+        return {"RTX 4090": 24, "RTX 5090": 32}
+
+
+GPU_VRAM_GB = _gpu_vram_table()
+
+_BYTES_PER_PARAM = {
+    "bf16": 2.0,
+    "fp16": 2.0,
+    "4bit-qlora": 0.55,  # NF4 weights + quantization constants
+}
+
+# Fixed overheads (GB): CUDA context + activations w/ gradient checkpointing +
+# LoRA params/grads/Adam states (tiny at rank<=64) + fragmentation headroom.
+_BASE_OVERHEAD_GB = 4.0
+# Activations with gradient checkpointing scale ~linearly with tokens-in-flight
+# (batch x seq) and model width (~sqrt of params). Coef calibrated so 4.7B SFT at
+# seq 32k / batch 1 lands ~22 GB (measured: fits a 32 GB 5090).
+_ACT_COEF = 0.12
+# Colocated-GRPO vLLM KV pool: grows with the engine's max context (seq) and model
+# width, but vLLM bounds the pool to a fraction of the card and PAGES rather than OOMs,
+# so it's capped (_KV_CAP) instead of growing without bound at long context.
+_KV_COEF = 2.0
+_KV_CAP = 8.0
+# GRPO backward (activations + fp32 logits over the completion micro-batch) per unit
+# context x model width. Grad checkpointing makes this MILD in seq -- calibrated to
+# measured boundaries: 0.8B GRPO fits 24 GB up to seq 32k (seq ~free), while 4.7B GRPO
+# steps off a 32 GB card between seq 16k and 32k. group size scales it sublinearly.
+_TRAIN_COEF = 0.27
+# Fixed floor for colocated-vLLM GRPO: the vLLM engine's CUDA context + KV pool (sized to the
+# CARD's VRAM via gpu_util, not the model) + the 2nd resident weight copy is ~model-independent
+# for small models and dominates their param estimate, so tiny/mid models all need the 32 GB tier.
+# MEASURED at the default group_size=8: 0.8B GRPO OOMs a 20 GB card; 2B GRPO OOMs a 24 GB card
+# (-> both need 32); 4B GRPO fits 32 (param est ~31 already clears this floor, so it's untouched).
+_VLLM_COLOCATE_FLOOR_GB = 28.0
+_VOCAB_DEFAULT = 152_000  # Qwen3.x tokenizer vocab (drives the fp32-logits GRPO term)
+# Matches the worker's RL_LOGITS_BUDGET_GB default: the per-device fp32 logits are capped to this
+# (rl_per_device_comps spills the rest into grad-accum), so the estimator never reserves above it.
+_LOGITS_BUDGET_GB = 6.0
+
+
+def grpo_seq_escalation_gb(params_b: float | None, seq_len: int) -> int:
+    """Extra GB a long-context GRPO run needs beyond its base footprint.
+
+    Big-model GRPO is tight: colocate holds 2 weight copies + a KV pool, so headroom shrinks
+    with model size and long context overflows it. Calibrated on a bf16 9.7B GRPO run (RunPod):
+    fits 80 GB to seq 4096 but OOMs at 8192. Safe headroom ~ 48500/params_b tokens; past that
+    escalate, STEEPER for bigger models. Applies to both catalog and open-model GRPO so neither
+    under-provisions.
+    """
+    coef = 0.9
+    if not params_b:
+        return 0
+    seq_thresh = 48_500.0 / params_b
+    if seq_len <= seq_thresh:
+        return 0
+    return math.ceil(coef * params_b * (seq_len / seq_thresh - 1))
+
+
+def params_b_from_str(s: str | None) -> float | None:
+    """Leading param count (billions) from a catalog ``params`` string, e.g.
+    "4.7B (text-only fine-tune)" -> 4.7, "9.7B (text-only fine-tune)" -> 9.7."""
+    if not s:
+        return None
+    m = re.search(r"([0-9]+(?:\.[0-9]+)?)\s*B", s)
+    return float(m.group(1)) if m else None
+
+
+@dataclass(frozen=True)
+class VramEstimate:
+    params_b: float | None
+    algorithm: str
+    quant: str
+    est_gb: float | None
+    gpu: str
+    gpu_gb: int
+    verdict: str  # "fits" | "tight" | "too_big" | "unknown"
+
+    def describe(self) -> str:
+        if self.est_gb is None:
+            return f"{self.gpu}: VRAM need unknown (could not read model size)"
+        return (
+            f"{self.gpu} ({self.gpu_gb} GB): estimated ~{self.est_gb:.0f} GB needed "
+            f"({self.params_b:.1f}B params, {self.quant}, {self.algorithm}) -> {self.verdict}"
+        )
+
+
+def estimate_vram_gb(
+    params_b: float,
+    algorithm: str,
+    quant: str = "bf16",
+    *,
+    seq_len: int = 1024,
+    max_tokens: int | None = None,
+    lora_rank: int = 32,
+    batch_size: int = 1,
+    group_size: int = 8,
+    thinking: bool = False,
+    use_vllm: bool = True,
+) -> float:
+    """Estimated peak VRAM (GB) for a LoRA job on one GPU, over the full knob matrix.
+
+    Terms (all in GB):
+      weights      params x bytes/param (bf16=2, 4bit-qlora=0.55)
+      base         CUDA context + framework + fragmentation headroom
+      lora_opt     LoRA adapter + grads + Adam states (rank-linear, model-scaled)
+      activations  grad-checkpointed activations ~ batch x seq x sqrt(params)
+      grpo only:
+        +weights   colocated vLLM holds a 2nd resident weight copy at the rollout peak
+                   (sleep mode offloads it BETWEEN steps, not during) -- skipped when
+                   use_vllm is False (transformers generation, single copy)
+        kv         vLLM KV pool ~ seq x sqrt(params)
+        logits     fp32 logits [per_device_comps, completion, vocab]
+    """
+    bpp = _BYTES_PER_PARAM.get(quant, 2.0)
+    weights = params_b * bpp
+    algo = "grpo" if (algorithm or "").lower() in ("grpo", "rl") else "sft"
+    width = math.sqrt(max(params_b, 0.1))
+    lora_opt = (lora_rank / 16.0) * (0.3 + 0.04 * params_b)
+    base = weights + _BASE_OVERHEAD_GB + lora_opt
+    if algo == "grpo":
+        # GRPO alternates two phases that DON'T peak together (sleep mode offloads the
+        # vLLM engine during the backward), so peak = max(rollout, train), not the sum:
+        #   rollout: colocated vLLM 2nd weight copy + KV pool (skipped if use_vllm=False)
+        #   train:   backward activations + fp32 logits -- MILD in seq (grad ckpt)
+        rollout = 0.0
+        if use_vllm:
+            rollout = weights + min(_KV_COEF * (seq_len / 1024.0) * width, _KV_CAP)
+        group_factor = max(1.0, (max(1, group_size) / 4.0) ** 0.5)
+        think_factor = 1.3 if thinking else 1.0
+        activations = _TRAIN_COEF * (seq_len / 1024.0) * width * group_factor * think_factor
+        # fp32 logits [per_device, completion, vocab] are the documented GRPO OOM driver. The
+        # worker MEMORY-CAPS per_device (rl_per_device_comps) so the live logits never exceed
+        # RL_LOGITS_BUDGET_GB and the rest spills into grad-accum -- so the IRREDUCIBLE floor the
+        # card must hold is the per_device=1 logits for the completion length: it scales with
+        # max_tokens (NOT seq_len) and is capped at the budget. completion defaults to the recipe
+        # budget (~min(seq_len, 1024)) when max_tokens is unset.
+        completion = max_tokens if max_tokens else min(seq_len, 1024)
+        logits = min(completion * _VOCAB_DEFAULT * 4 / 1e9, _LOGITS_BUDGET_GB)
+        train = activations + logits
+        return base + max(rollout, train)
+    return base + _ACT_COEF * max(1, batch_size) * (seq_len / 1024.0) * width
+
+
+def model_required_vram_gb(
+    model_id: str,
+    algorithm: str,
+    *,
+    train=None,
+    thinking: bool = False,
+    headroom: float = 1.1,
+) -> int:
+    """Cheapest-sufficient VRAM (GB) for a specific run -- the matrix the allocator and
+    ``resolve_gpu_policy`` both size against.
+
+    Catalog models size from their known param count + the run's actual knobs (``train``
+    may be a TrainSpec, a dict, or None for recipe defaults). Curated GRPO floors
+    (``grpo_min_vram_gb``) stay as HARD floors so we never under-provision a validated
+    model; the matrix only ever sizes UP from there. Unlisted open models size from HF
+    metadata, falling back to the 24 GB tier when the size can't be read.
+    """
+
+    # Best-effort knob extraction: this provisional sizing runs at parse time BEFORE the
+    # dedicated train validators, so malformed knobs (nan/inf/strings/<=0) must fall back
+    # to a default here, never crash -- config_schema raises the proper ConfigError next.
+    def _g(obj, key):
+        if obj is None:
+            return None
+        return obj.get(key) if isinstance(obj, dict) else getattr(obj, key, None)
+
+    def _pos_int(v, default):
+        try:
+            if isinstance(v, bool):
+                return default
+            f = float(v)
+            return int(f) if math.isfinite(f) and f >= 1 else default
+        except (TypeError, ValueError):
+            return default
+
+    seq_len = _pos_int(_g(train, "max_length"), 1024)
+    max_tokens = _pos_int(_g(train, "max_tokens"), None)
+    lora_rank = _pos_int(_g(train, "lora_rank"), 32)
+    group_size = _pos_int(_g(train, "group_size"), 8)
+    batch_size = _pos_int(_g(train, "batch_size"), 1)
+
+    def _need(
+        params_b: float, algorithm: str, *, quant: str = "bf16", use_vllm: bool = True
+    ) -> int:
+        # estimate over the run's full knob matrix, then apply the safety headroom. Both the
+        # catalog and open-model paths size through here so they stay in sync on the knob set.
+        est = estimate_vram_gb(
+            params_b,
+            algorithm,
+            quant,
+            seq_len=seq_len,
+            max_tokens=max_tokens,
+            lora_rank=lora_rank,
+            batch_size=batch_size,
+            group_size=group_size,
+            thinking=thinking,
+            use_vllm=use_vllm,
+        )
+        return math.ceil(est * headroom)
+
+    from autoslm.catalog import MODELS
+
+    info = MODELS.get(model_id)
+    is_grpo = (algorithm or "").lower() in ("grpo", "rl")
+    if info is not None:
+        params_b = params_b_from_str(info.params)
+        quant = getattr(info, "quant", "bf16") or "bf16"
+        # GRPO always runs the rollout on a colocated vLLM engine, so sizing must reserve room for
+        # the 2nd (rollout) weight copy on the same card.
+        use_vllm = True
+        need = _need(params_b or 4.0, algorithm, quant=quant, use_vllm=use_vllm)
+        # Hard floor the param-based matrix can't see: a curated GRPO floor.
+        floor = 0
+        if is_grpo and getattr(info, "grpo_min_vram_gb", 0):
+            floor = int(info.grpo_min_vram_gb)
+        if quant == "4bit-qlora":
+            # GRPO needs the curated grpo_min_vram_gb (2 weight copies + KV); SFT is single-copy and
+            # fits the smaller min_vram_gb. Don't leak the GRPO floor into SFT allocations or SFT
+            # over-provisions.
+            _q_floor = (
+                int(getattr(info, "grpo_min_vram_gb", 0) or info.min_vram_gb)
+                if is_grpo
+                else int(info.min_vram_gb)
+            )
+            floor = max(floor, _q_floor)
+        # Big-model GRPO is TIGHT at its floor (2 weight copies + KV pool), so long context
+        # overflows it -> escalate to a bigger tier. See grpo_seq_escalation_gb.
+        if is_grpo and floor:
+            floor += grpo_seq_escalation_gb(params_b, seq_len)
+        need = max(need, floor)
+        # vLLM-colocate floor: the engine (CUDA context + KV pool sized to the CARD's VRAM +
+        # framework) + the 2nd resident weight copy add a ~constant the param estimate misses,
+        # so small-model GRPO under-provisions. MEASURED at the default group_size=8: 0.8B GRPO
+        # fits a 24 GB card but OOMs 20 (est ~18, ~6 GB headroom on 24); 2B GRPO OOMs a 24 GB
+        # card (est ~20 but the colocate cost tips it past 24 -> needs the 32 tier). So sub-~1B
+        # models floor at 24, while larger small-models that the param estimate still under-shoots
+        # floor at the 32 tier. 4B+ already exceed this via their param estimate, so untouched.
+        if is_grpo and use_vllm:
+            floor_gb = 24 if (params_b or 0.0) <= 1.0 else int(_VLLM_COLOCATE_FLOOR_GB)
+            need = max(need, floor_gb)
+        return need
+    # Unlisted open model: size from HF metadata (GRPO is the heavier phase).
+    params_b = fetch_hf_params_b(model_id)
+    if params_b is None:
+        return 24
+    # Open models size against the heavier GRPO phase regardless of the requested algorithm.
+    need = _need(params_b, "grpo")
+    # Same long-context GRPO escalation as the catalog path so a big open model isn't
+    # under-provisioned at long context either.
+    if is_grpo:
+        need += grpo_seq_escalation_gb(params_b, seq_len)
+    return need
+
+
+def fetch_hf_params_b(model_id: str) -> float | None:
+    """Total params (billions) from the HF API safetensors metadata (no download)."""
+    if os.environ.get("AUTOSLM_SKIP_NET"):
+        return None
+    try:
+        from huggingface_hub import HfApi
+
+        info = HfApi(token=os.environ.get("HF_TOKEN")).model_info(
+            model_id, expand=["safetensors"]
+        )
+        total = getattr(getattr(info, "safetensors", None), "total", None)
+        if total:
+            return float(total) / 1e9
+    except Exception:
+        # Best-effort size probe (network/HF-metadata may be unavailable); fall through
+        # to None so callers report "size unknown" rather than failing.
+        pass
+    return None
+
+
+def check_fit(
+    model_id: str,
+    algorithm: str,
+    gpu: str,
+    quant: str = "bf16",
+    params_b: float | None = None,
+) -> VramEstimate:
+    """Estimate whether ``model_id`` plausibly trains on ``gpu``; never raises."""
+    gpu_gb = GPU_VRAM_GB.get(gpu, 32)
+    if params_b is None:
+        params_b = fetch_hf_params_b(model_id)
+    if params_b is None:
+        return VramEstimate(None, algorithm, quant, None, gpu, gpu_gb, "unknown")
+    est = estimate_vram_gb(params_b, algorithm, quant)
+    if est > gpu_gb * 1.15:
+        verdict = "too_big"
+    elif est > gpu_gb * 0.85:
+        verdict = "tight"
+    else:
+        verdict = "fits"
+    return VramEstimate(params_b, algorithm, quant, est, gpu, gpu_gb, verdict)

code/autoslm/envs/__init__.py

@@ -0,0 +1,10 @@
+"""Pluggable fine-tune/evaluation environments."""
+
+from .base import BaseEnvironment, Environment
+from .registry import load_environment
+
+__all__ = [
+    "BaseEnvironment",
+    "Environment",
+    "load_environment",
+]

code/autoslm/envs/adapter.py

@@ -0,0 +1,706 @@
+"""Adapter that runs Prime Intellect ``verifiers`` / Environments Hub envs on AutoSLM.
+
+Wraps a ``verifiers`` ``Environment`` (``SingleTurnEnv``, ``MultiTurnEnv``, ``ToolEnv`` and
+its subclasses) in AutoSLM's small ``Environment`` protocol so Hub environments run unchanged
+on AutoSLM's trainer.
+
+GRPO supports all three shapes (the worker routes on ``multi_turn`` / ``is_tool_env``):
+  * single-turn — TRL's single-shot generation + per-completion reward;
+  * tool (``ToolEnv`` / ``StatefulToolEnv`` / ``SandboxEnv`` / ``PythonEnv``) — TRL drives the
+    tool-call loop natively via ``GRPOTrainer(tools=...)`` (:meth:`tools`), masking tool tokens
+    itself; the reward scores the full transcript (:meth:`reward_from_messages`);
+  * pure multi-turn — ``autoslm.engine.multiturn_rollout`` supplies a ``rollout_func`` that
+    drives this env's turn loop on the colocate engine via the adapter rollout helpers
+    (:meth:`new_rollout_state` / :meth:`record_model_turn` / :meth:`env_reply` /
+    :meth:`rollout_done`) and returns an ``env_mask`` so only model tokens are trained.
+
+Caveats:
+  * SFT on a multi-turn/tool env only fits the single assistant ``sft_target`` per row and
+    ignores tool/env turns, so it should be avoided (see ``run_sft`` / ``sft_target``);
+  * a ``StatefulToolEnv`` whose tools need verifiers' state-injection (``update_tool_args``)
+    is only fully honored on the rollout path — under TRL's native tool loop the tools are
+    called as plain functions.
+
+verifiers contract (docs):
+  * ``vf.load_environment(env_id, **kwargs) -> Environment``
+  * rows have ``prompt`` (chat messages) + ``answer`` (+ optional ``info``)
+  * ``env.dataset`` / ``env.get_dataset(n, seed)``, ``env.eval_dataset`` / ``get_eval_dataset``
+  * ``env.system_prompt``, ``env.parser``, ``env.rubric`` (weighted reward funcs that take
+    ``completion``/``prompt``/``answer``/``info``/``state``/``parser``/``judge`` by name; sync or async)
+  * multi-turn: ``env.env_response(messages, state)`` -> env reply messages;
+    ``env.is_completed(state)`` -> done flag (both async)
+
+Hub conveniences handled here so the *documented* flow (``slm env install owner/name`` +
+``[environment] id = "owner/name"``) works on real Prime Intellect envs:
+  * the ``owner/name`` Hub slug is mapped to the bare ``verifiers`` load id;
+  * a ``RubricGroup`` (rubrics-of-rubrics) is flattened so the real reward funcs are found;
+    zero-weight monitor funcs still run (for shared-state side effects / logging) with their
+    exceptions guarded, but contribute 0 — only weighted funcs count toward the reward;
+  * a ``JudgeRubric``'s judge client/model/prompt is supplied to reward funcs that declare a
+    ``judge``/``judge_client``/``judge_model``/``judge_prompt`` arg, so judge-based rewards run;
+  * named per-scorer breakdowns (``scores_breakdown``) expose each reward func's weighted
+    score so the frontend per-scorer view + W&B series survive;
+  * an optional separate **eval** Hub env (``eval_env_id``) + a fixed eval subset
+    (``eval_examples`` / ``eval_seed``) let you train on one env and evaluate on another.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import inspect
+import json
+import random
+
+from .base import BaseEnvironment
+
+# The judge-related kwarg names a reward func may declare, sourced from a JudgeRubric.
+# Single source of truth for both ``_judge_kwargs`` and ``_AVAILABLE_REWARD_KWARGS``.
+_JUDGE_KWARG_NAMES = ("judge", "judge_client", "judge_model", "judge_prompt")
+
+# The kwargs this adapter can supply to a reward func. The non-judge keys are exactly the
+# ones built into the ``available`` dict in VerifiersEnvironment._reward_available; the judge
+# keys come from ``_judge_kwargs``. Deriving the frozenset from these shared names avoids the
+# manual "keep in sync" coupling (adding a kwarg below without updating the set would
+# re-trigger the false "requires unavailable arg" failure).
+_BASE_REWARD_KWARG_NAMES = (
+    "completion",
+    "prompt",
+    "answer",
+    "info",
+    "state",
+    "parser",
+    "task",
+)
+_AVAILABLE_REWARD_KWARGS = frozenset(_BASE_REWARD_KWARG_NAMES + _JUDGE_KWARG_NAMES)
+
+
+def _reward_requires_unavailable_args(func) -> str | None:
+    """Name of a required arg this adapter cannot supply, or None.
+
+    Group/batch reward funcs declare plural required params (``completions``,
+    ``prompts``, ``answers``, ...). The worker scores one completion at a time and has no
+    batch, so such a func would be called without its required argument and silently score
+    0.0 — train/eval on an all-zero signal. Detect it so the caller can fail fast."""
+    try:
+        params = inspect.signature(func).parameters.values()
+    except (TypeError, ValueError):
+        return None  # builtins/uninspectable: _invoke_reward passes everything
+    for p in params:
+        if p.kind in (p.VAR_KEYWORD, p.VAR_POSITIONAL):
+            continue
+        if p.default is inspect.Parameter.empty and p.name not in _AVAILABLE_REWARD_KWARGS:
+            return p.name
+    return None
+
+
+def vf_load_id(env_ref: str) -> str:
+    """Map a Hub slug (``owner/name``) to the bare ``verifiers`` load id (``name``)."""
+    return env_ref.split("/", 1)[1] if "/" in env_ref else env_ref
+
+
+# AutoSLM-reserved keys that may historically have ridden in [environment.params] but are
+# NOT verifiers ``load_environment`` kwargs. They are handled by the worker/adapter directly
+# (eval_* via named params; GRPO recipe knobs now live in [train]/TrainSpec). A stray one must
+# be dropped before forwarding to ``vf.load_environment`` — passing it through would raise a
+# TypeError in the env's loader (or silently change its behavior). The eval_* keys are also
+# listed here so the catch-all guard never forwards them even if they reach **kwargs.
+_RESERVED_ENV_PARAM_KEYS = frozenset(
+    {
+        "eval_env_id",
+        "eval_examples",
+        "eval_seed",
+        "grpo_config",
+        "sft_config",
+        "mode",
+        "records",
+        "eval_records",
+        "reward_command",
+    }
+)
+
+
+def _drop_reserved_kwargs(kwargs: dict) -> dict:
+    """Strip AutoSLM-reserved keys so only true verifiers-env kwargs are forwarded."""
+    dropped = [k for k in kwargs if k in _RESERVED_ENV_PARAM_KEYS]
+    if dropped:
+        print(
+            "[verifiers-adapter] dropping AutoSLM-reserved [environment.params] keys not "
+            f"accepted by vf.load_environment: {', '.join(sorted(dropped))}"
+        )
+    return {k: v for k, v in kwargs.items() if k not in _RESERVED_ENV_PARAM_KEYS}
+
+
+def _run_async(coro):
+    """Run an awaitable to completion from sync code, even inside a running loop."""
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+    # Already inside a loop (rare for the worker): run in a fresh loop on a thread.
+    import concurrent.futures
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex:
+        return ex.submit(lambda: asyncio.run(coro)).result()
+
+
+def _call_dataset_getter(obj, method_name: str, *, seed: int):
+    """Call a verifiers dataset getter, binding (n, seed) when it declares them.
+
+    verifiers exposes get_dataset/get_eval_dataset as get_X(n=-1, seed=0); some Hub envs
+    declare them WITHOUT defaults, so a no-arg call raised TypeError, swallowed into an empty
+    dataset (a paid run over no data). Bind n=-1 (all rows — the adapter does its own fixed
+    subset selection) and the seed when the signature declares them; a genuine failure
+    propagates (fail loudly) instead of silently emptying the split."""
+    fn = getattr(obj, method_name, None)
+    if not callable(fn):
+        return None
+    try:
+        param_names = set(inspect.signature(fn).parameters)
+    except (TypeError, ValueError):
+        param_names = set()
+    kwargs = {}
+    if "n" in param_names:
+        kwargs["n"] = -1
+    if "seed" in param_names:
+        kwargs["seed"] = seed
+    return fn(**kwargs)
+
+
+def _rows_to_list(ds) -> list[dict]:
+    if ds is None:
+        return []
+    try:
+        return [dict(r) for r in ds]
+    except Exception:
+        return list(ds)
+
+
+def _flatten_rubric(rubric) -> list[tuple]:
+    """Collect ``(func, weight)`` pairs from a rubric, recursing into ``RubricGroup``.
+
+    verifiers composes rubrics (e.g. a ``RubricGroup`` wrapping a ``MathRubric`` plus a
+    ``MultiTurnMonitorRubric``); the real reward funcs live on the *nested* rubrics while the
+    group's own ``funcs`` is empty. Flattening finds them all.
+    """
+    funcs = list(getattr(rubric, "funcs", None) or getattr(rubric, "reward_funcs", None) or [])
+    weights = list(
+        getattr(rubric, "weights", None) or getattr(rubric, "reward_weights", None) or []
+    )
+    if len(weights) < len(funcs):
+        weights += [1.0] * (len(funcs) - len(weights))
+    pairs = list(zip(funcs, weights, strict=False))
+    for sub in getattr(rubric, "rubrics", None) or []:
+        pairs.extend(_flatten_rubric(sub))
+    return pairs
+
+
+def _find_judge_rubric(rubric):
+    """Return the first ``JudgeRubric`` in a rubric tree (or None), for judge-arg injection."""
+    if rubric is None:
+        return None
+    try:
+        import verifiers as vf
+
+        judge_cls = getattr(vf, "JudgeRubric", None)
+    except ImportError:
+        judge_cls = None
+    if judge_cls is not None and isinstance(rubric, judge_cls):
+        return rubric
+    # Duck-type fallback: anything exposing a `judge` method + a judge_client attr.
+    if callable(getattr(rubric, "judge", None)) and hasattr(rubric, "judge_client"):
+        return rubric
+    for sub in getattr(rubric, "rubrics", None) or []:
+        found = _find_judge_rubric(sub)
+        if found is not None:
+            return found
+    return None
+
+
+def _judge_kwargs(judge_rubric) -> dict:
+    """The judge-related kwargs a reward func may declare, sourced from a JudgeRubric."""
+    if judge_rubric is None:
+        return {}
+    return {name: getattr(judge_rubric, name, None) for name in _JUDGE_KWARG_NAMES}
+
+
+def _invoke_reward(func, available: dict) -> float:
+    """Call a verifiers reward func passing only the kwargs it declares; await if async.
+
+    Exceptions PROPAGATE. ``scores_breakdown`` invokes this for *weighted* reward funcs, so an
+    exception here is a real (weighted) reward func genuinely failing (e.g. a JudgeRubric judge
+    raising on an API/rate-limit error, or a parse error on row data). Swallowing it as 0.0
+    would silently train/score on an all-zero signal and waste a paid run, so we fail loudly
+    instead. Zero-weight (optional/monitor) funcs are run through ``_run_zero_weight_reward``,
+    which swallows their exceptions — they contribute 0 either way and may exist only for their
+    side effects (mutating shared ``state`` / logging), so a thrown monitor must not fail a run.
+    """
+    try:
+        params = inspect.signature(func).parameters
+        if any(p.kind == p.VAR_KEYWORD for p in params.values()):
+            kwargs = dict(available)
+        else:
+            kwargs = {k: v for k, v in available.items() if k in params}
+    except (TypeError, ValueError):
+        kwargs = dict(available)
+    result = func(**kwargs)
+    if inspect.isawaitable(result):
+        result = _run_async(result)
+    return float(result or 0.0)
+
+
+def _run_zero_weight_reward(func, available: dict) -> None:
+    """Run a zero-weight monitor/diagnostic reward func, swallowing any exception.
+
+    Per verifiers semantics every reward func RUNS, even weight-0 ones: they may mutate the
+    shared ``state`` (so a later weighted func sees their work) or simply be logged. They never
+    contribute to the reward (weight is 0), so their result is discarded and a failure must NOT
+    fail the run — guard the exception. Weighted funcs go through ``_invoke_reward`` instead,
+    where exceptions propagate.
+    """
+    with contextlib.suppress(Exception):
+        _invoke_reward(func, available)
+
+
+def _is_multi_turn(vf_env) -> bool:
+    """True for a tool/multi-turn verifiers env (NOT a plain SingleTurnEnv)."""
+    try:
+        import verifiers as vf
+    except ImportError:
+        return False
+    tool = getattr(vf, "ToolEnv", None)
+    multi = getattr(vf, "MultiTurnEnv", None)
+    single = getattr(vf, "SingleTurnEnv", None)
+    if tool is not None and isinstance(vf_env, tool):
+        return True
+    if multi is not None and isinstance(vf_env, multi):
+        # SingleTurnEnv subclasses MultiTurnEnv in verifiers; exempt it.
+        return not (single is not None and isinstance(vf_env, single))
+    return False
+
+
+def _is_tool_env(vf_env) -> bool:
+    """True for a verifiers ``ToolEnv`` or any subclass (Stateful/Sandbox/Python).
+
+    Tool envs expose Python tool callables; the worker hands those to TRL's
+    ``GRPOTrainer(tools=...)`` so TRL drives the tool-call loop natively (it owns generation,
+    tool execution, and assistant-only token masking). A *pure* ``MultiTurnEnv`` (env turns are
+    arbitrary content, e.g. a simulated user) is multi-turn but NOT a tool env, and takes the
+    ``rollout_func`` path instead."""
+    try:
+        import verifiers as vf
+    except ImportError:
+        return False
+    tool = getattr(vf, "ToolEnv", None)
+    return tool is not None and isinstance(vf_env, tool)
+
+
+class VerifiersEnvironment(BaseEnvironment):
+    """AutoSLM environment backed by a verifiers ``Environment`` instance.
+
+    GRPO training supports three env shapes (the worker routes on these flags):
+      * **single-turn** (``multi_turn`` False) — TRL's single-shot rollout (original path);
+      * **tool** (``is_tool_env`` True) — TRL drives the tool-call loop natively via
+        ``GRPOTrainer(tools=...)`` (:meth:`tools`); the reward scores the full transcript
+        (:meth:`reward_from_messages`);
+      * **pure multi-turn** (``multi_turn`` True, ``is_tool_env`` False) — TRL's
+        ``rollout_func`` drives this env's turn loop (:meth:`new_rollout_state` /
+        :meth:`record_model_turn` / :meth:`env_reply` / :meth:`rollout_done`).
+    """
+
+    def __init__(
+        self,
+        vf_env,
+        env_id: str,
+        eval_vf_env=None,
+        eval_examples: int | None = None,
+        eval_seed: int = 12345,
+    ):
+        super().__init__(id=env_id)
+        self._env = vf_env
+        self._eval_env = eval_vf_env  # optional separate eval Hub env
+        self._eval_examples = int(eval_examples) if eval_examples else 0
+        self._eval_seed = int(eval_seed)
+        self.multi_turn = _is_multi_turn(vf_env)
+        self.is_tool_env = _is_tool_env(vf_env)
+        # Turn cap for the tool / multi-turn rollout loop (verifiers ToolEnv defaults to 10).
+        self.max_turns = int(getattr(vf_env, "max_turns", 10) or 10)
+        # The shared scorer is the TRAIN env's (flattened) rubric + parser, so the reward used
+        # for RL and the grader used at eval are byte-for-byte identical.
+        rubric = getattr(vf_env, "rubric", None)
+        self._reward_pairs = _flatten_rubric(rubric) if rubric is not None else []
+        self._judge_rubric = _find_judge_rubric(rubric)
+        # Fail fast on a group/batch reward func: the worker scores one completion at a time
+        # and cannot supply its plural batch args, so it would silently score 0.0 and train a
+        # paid run on an all-zero signal. Only weighted funcs matter (zero-weight ones skip).
+        for func, weight in self._reward_pairs:
+            if not weight:
+                continue
+            missing = _reward_requires_unavailable_args(func)
+            if missing:
+                raise ValueError(
+                    f"verifiers reward function {getattr(func, '__name__', func)!r} requires "
+                    f"argument {missing!r}, which the AutoSLM adapter cannot supply (it scores "
+                    "one completion at a time, with no group/batch context such as "
+                    "completions/prompts/answers). This environment uses a group-based reward "
+                    "not supported on AutoSLM; use a per-completion reward."
+                )
+        self._parser = getattr(vf_env, "parser", None)
+
+    # -- data -------------------------------------------------------------
+    def dataset(self, split: str) -> list[dict]:
+        is_eval = split in {"eval", "validation", "test"}
+        if is_eval:
+            src = self._eval_env or self._env
+            # Resolve the eval source with explicit ``is None`` checks (NOT ``or``): an
+            # empty-but-configured eval split (``[]``) is falsy, so ``or`` would wrongly
+            # fall through to the next source and ultimately to the TRAIN split — evaluating
+            # on training data. Only fall back when the eval source is genuinely *absent*
+            # (None), not merely empty. ``get_eval_dataset``/``eval_dataset`` returning [] is
+            # a deliberate empty eval set and must be honored as such.
+            eval_ds = _call_dataset_getter(src, "get_eval_dataset", seed=self._eval_seed)
+            if eval_ds is None:
+                eval_ds = getattr(src, "eval_dataset", None)
+            if eval_ds is None:  # no eval split configured at all: use the env's train split
+                eval_ds = _call_dataset_getter(src, "get_dataset", seed=self._eval_seed)
+                if eval_ds is None:
+                    eval_ds = getattr(src, "dataset", None)
+            rows = _rows_to_list(eval_ds)
+            return self._fixed_subset(rows)
+        ds = _call_dataset_getter(self._env, "get_dataset", seed=0)
+        if ds is None:
+            ds = getattr(self._env, "dataset", None)
+        return _rows_to_list(ds)
+
+    def _fixed_subset(self, rows: list[dict]) -> list[dict]:
+        n = self._eval_examples
+        if n <= 0 or n >= len(rows):
+            return rows
+        idx = sorted(random.Random(self._eval_seed).sample(range(len(rows)), n))
+        return [rows[i] for i in idx]
+
+    # -- task interface ---------------------------------------------------
+    def prompt_messages(self, example: dict) -> list[dict]:
+        prompt = example.get("prompt")
+        if isinstance(prompt, list) and prompt:
+            msgs = [dict(m) for m in prompt]
+        else:
+            question = example.get("question") or example.get("prompt") or ""
+            msgs = [{"role": "user", "content": str(question)}]
+        system_prompt = getattr(self._env, "system_prompt", None)
+        if system_prompt and not any(m.get("role") == "system" for m in msgs):
+            msgs = [{"role": "system", "content": system_prompt}, *msgs]
+        return msgs
+
+    def sft_target(self, example: dict) -> str:
+        for key in ("answer", "completion", "target", "response"):
+            value = example.get(key)
+            if value:
+                if isinstance(value, list):  # chat messages
+                    return str(value[-1].get("content", ""))
+                return str(value)
+        return ""
+
+    # -- reward / scoring -------------------------------------------------
+    def _normalize_info(self, example: dict) -> dict:
+        # Hub rows may store `info` as a JSON string (a supported Verifiers row shape);
+        # parse it so reward funcs that do `info[...]` get a dict, not a str (which would
+        # raise TypeError, be swallowed as 0.0, and poison the signal).
+        info = example.get("info") or {}
+        if isinstance(info, str):
+            try:
+                info = json.loads(info)
+            except (ValueError, TypeError):
+                info = {}
+        return info
+
+    def _reward_available(self, completion: str, example: dict, state: dict | None) -> dict:
+        # In multi-turn/tool mode the accumulated transcript lives on ``state`` (built by the
+        # rollout helpers): ``state["completion"]`` is the full assistant + tool/env message
+        # list and ``state["prompt"]`` is the initial prompt. Reward/tool funcs that inspect the
+        # whole message list need that transcript, not the scalar ``completion`` string wrapped
+        # as a lone synthesized assistant message. Single-turn falls back to wrapping the scalar.
+        completion_msgs: list[dict] | None = None
+        prompt_msgs = None
+        if self.multi_turn and state:
+            transcript = state.get("completion")
+            if isinstance(transcript, list) and transcript:
+                completion_msgs = [dict(m) for m in transcript]
+            state_prompt = state.get("prompt")
+            if isinstance(state_prompt, list) and state_prompt:
+                prompt_msgs = [dict(m) for m in state_prompt]
+        if completion_msgs is None:
+            completion_msgs = [{"role": "assistant", "content": completion}]
+        if prompt_msgs is None:
+            prompt_msgs = example.get("prompt") or self.prompt_messages(example)
+        available = {
+            "completion": completion_msgs,
+            "prompt": prompt_msgs,
+            "answer": example.get("answer"),
+            "info": self._normalize_info(example),
+            "state": state if state is not None else {},
+            "parser": self._parser,
+            "task": example,
+        }
+        available.update(_judge_kwargs(self._judge_rubric))
+        return available
+
+    def scores_breakdown(
+        self, completion: str, example: dict, state: dict | None = None
+    ) -> dict[str, float]:
+        """Per-scorer weighted scores: ``{func_name: weighted_score, ..., "total": sum}``.
+
+        Every WEIGHTED rubric func contributes one entry (by ``func.__name__``); the
+        ``"total"`` is their sum (== :meth:`reward`). Used to preserve the frontend per-scorer
+        breakdown + W&B series instead of collapsing to a single binary ``correct``.
+
+        Per verifiers semantics EVERY reward func runs, including zero-weight ones — they may
+        mutate the shared ``state`` (so a subsequent weighted func sees their work) or exist
+        only to be logged. Zero-weight funcs run with GUARDED exceptions (a thrown monitor must
+        not fail the run) and contribute 0, so they are not added to the breakdown/total; the
+        order is preserved so a zero-weight func can prepare state for a later weighted one.
+        Weighted funcs propagate exceptions (a thrown weighted reward fails the run).
+        """
+        breakdown: dict[str, float] = {}
+        if not self._reward_pairs:
+            answer = str(example.get("answer") or "")
+            score = 1.0 if answer and answer in (completion or "") else 0.0
+            return {"answer_match": score, "total": score}
+        available = self._reward_available(completion, example, state)
+        total = 0.0
+        for func, weight in self._reward_pairs:
+            if not weight:
+                # Zero-weight monitor/diagnostic func: RUN it (for its side effects on shared
+                # state / logging) with guarded exceptions, but it contributes 0 and is not in
+                # the named breakdown.
+                _run_zero_weight_reward(func, available)
+                continue
+            name = getattr(func, "__name__", str(func))
+            score = float(weight) * _invoke_reward(func, available)
+            # Collisions (two funcs share a name): keep them distinct so neither is lost.
+            # Probe for an unused exact key — a prefix/length heuristic can recompute a
+            # suffix that collides with an already-recorded key (e.g. ``score`` vs
+            # ``score_detail``) and silently overwrite a scorer.
+            if name in breakdown:
+                base = name
+                i = 1
+                while name in breakdown:
+                    name = f"{base}_{i}"
+                    i += 1
+            breakdown[name] = score
+            total += score
+        breakdown["total"] = total
+        return breakdown
+
+    def reward(self, completion: str, example: dict, state: dict | None = None) -> float:
+        return float(self.scores_breakdown(completion, example, state)["total"])
+
+    def tools(self) -> list:
+        """The underlying ToolEnv's Python tool callables (``[]`` for non-tool envs).
+
+        Handed to ``GRPOTrainer(tools=...)`` so TRL runs the tool-call loop and does the
+        assistant-only token masking itself. Each is a plain function with type hints + a
+        Google-style docstring (verifiers and TRL share that requirement)."""
+        return list(getattr(self._env, "tools", None) or [])
+
+    def reward_from_messages(
+        self, completion_msgs: list[dict], example: dict, prompt_msgs: list[dict] | None = None
+    ) -> float:
+        """Reward for a full transcript (assistant + tool/env messages) via the rubric.
+
+        The tool / multi-turn training path produces a *message list* rollout rather than a
+        single completion string; this routes it through the same weighted-rubric scoring as
+        :meth:`reward` by handing the transcript to the env's reward funcs as ``state``."""
+        state: dict = {"completion": [dict(m) for m in completion_msgs]}
+        if prompt_msgs:
+            state["prompt"] = [dict(m) for m in prompt_msgs]
+        return self.reward("", example, state)
+
+    def grade(self, completion: str, example: dict, state: dict | None = None) -> bool:
+        threshold = getattr(self._env, "pass_threshold", 0.5)
+        return self.reward(completion, example, state) >= threshold
+
+    # -- multi-turn rollout (driven by the worker) ------------------------
+    def new_rollout_state(self, example: dict) -> dict:
+        """A fresh per-rollout ``state`` dict, threaded through env_reply/reward.
+
+        Mirrors the verifiers rollout ``state``: holds the running ``prompt``, the
+        accumulated ``completion`` (assistant + tool/env turns), the ``answer``/``info``, and
+        a ``turn`` counter. Reward funcs that read ``state`` see this dict.
+        """
+        prompt = self.prompt_messages(example)
+        state = {
+            "prompt": [dict(m) for m in prompt],
+            "completion": [],
+            "answer": example.get("answer"),
+            "info": self._normalize_info(example),
+            "responses": [],
+            "turn": 0,
+        }
+        setup = getattr(self._env, "setup_state", None)
+        if callable(setup):
+            with contextlib.suppress(Exception):
+                state = _run_async(setup(state)) or state
+        return state
+
+    def env_reply(self, messages: list[dict], state: dict) -> list[dict]:
+        """One environment turn: given the conversation so far (incl. the latest model
+        message), return the env's reply messages (tool results / next user turn) and advance
+        ``state``. Empty list when the env has nothing to add. Single-turn envs return []."""
+        if not self.multi_turn:
+            return []
+        fn = getattr(self._env, "env_response", None)
+        if not callable(fn):
+            return []
+        try:
+            reply = _run_async(fn(messages, state))
+        except NotImplementedError:
+            # Legitimate "this env has no env turn" signal -> no env reply.
+            return []
+        except Exception as exc:
+            # Mirror `_invoke_reward`: a genuine bug in the env's `env_response` must
+            # NOT be swallowed. Silently returning [] would collapse every multi-turn
+            # rollout to a single turn and train a paid GRPO run on degenerate
+            # transcripts. The rollout loop (multiturn_rollout.py) calls this directly
+            # with no surrounding swallow, so re-raising propagates and fails the run
+            # fast (and the context is printed first so it never vanishes silently).
+            print(f"[env_reply] env_response failed (turn={state.get('turn', 0)}): {exc!r}")
+            raise
+        if reply is None:
+            return []
+        if isinstance(reply, dict):
+            reply = [reply]
+        out = [dict(m) for m in reply]
+        state["completion"].extend(out)
+        state["turn"] = int(state.get("turn", 0)) + 1
+        return out
+
+    def rollout_done(self, state: dict, max_turns: int | None = None) -> bool:
+        """Whether the multi-turn rollout should stop (env says completed, or turn cap hit)."""
+        if not self.multi_turn:
+            return True
+        if max_turns is not None and int(state.get("turn", 0)) >= int(max_turns):
+            return True
+        fn = getattr(self._env, "is_completed", None)
+        if not callable(fn):
+            return True
+        try:
+            return bool(_run_async(fn(state)))
+        except NotImplementedError:
+            # Env doesn't implement a completion check -> rely on the turn cap only.
+            return True
+        except Exception as exc:
+            # Mirror `_invoke_reward` / `env_reply`: a real bug in `is_completed` must
+            # not be silently treated as "done" (which would truncate every rollout and
+            # train on degenerate transcripts). Print context, then re-raise so the run
+            # fails fast (the rollout loop calls this directly with no surrounding swallow).
+            print(f"[rollout_done] is_completed failed (turn={state.get('turn', 0)}): {exc!r}")
+            raise
+
+    def record_model_turn(self, state: dict, content: str) -> dict:
+        """Append a model (assistant) turn to ``state`` before calling ``env_reply``."""
+        msg = {"role": "assistant", "content": content}
+        state["completion"].append(msg)
+        state.setdefault("responses", []).append(content)
+        return msg
+
+
+def _import_vf():
+    try:
+        import verifiers as vf
+
+        return vf
+    except ImportError as exc:
+        raise ImportError(
+            "the 'verifiers' package is required to run Prime Hub environments; "
+            "install it (e.g. `uv pip install verifiers`) or run `slm env install <env>`"
+        ) from exc
+
+
+def _ensure_hub_module_importable(load_id: str) -> None:
+    """Make ``vf.load_environment(load_id)`` importable when the installed env package's
+    top-level module name has drifted from the slug.
+
+    ``vf.load_environment`` imports the slug as a module (``name`` -> ``name.replace("-","_")``).
+    Repeated Prime Hub re-publishes can leave a distribution whose *dist* name matches the slug
+    but whose *module* name is from an earlier push, so the expected import fails. When that
+    happens, locate the installed distribution for the slug, import its real top-level module,
+    and alias it under the expected name so the load succeeds.
+    """
+    import importlib
+    import importlib.util
+    import re as _re
+    import sys as _sys
+    from importlib import metadata as _md
+
+    expected = _re.sub(r"[^0-9A-Za-z_]", "_", load_id.replace("-", "_"))
+    if expected[:1].isdigit():
+        expected = "env_" + expected
+    try:
+        if importlib.util.find_spec(expected) is not None:
+            return
+    except (ImportError, ValueError):
+        pass
+    try:
+        dist = _md.distribution(load_id)
+    except _md.PackageNotFoundError:
+        return
+    # Top-level modules: prefer top_level.txt, else derive from the dist's file list (modern
+    # wheels often omit top_level.txt). A top-level ``foo.py`` -> module ``foo``; a top-level
+    # ``foo/__init__.py`` -> package ``foo``.
+    tops: list[str] = [t for t in (dist.read_text("top_level.txt") or "").split() if t]
+    if not tops:
+        seen: set[str] = set()
+        for f in dist.files or []:
+            parts = str(f).split("/")
+            if len(parts) == 1 and parts[0].endswith(".py") and parts[0] != "__init__.py":
+                mod = parts[0][:-3]
+            elif len(parts) >= 2 and parts[1] == "__init__.py" and not parts[0].endswith(
+                ".dist-info"
+            ):
+                mod = parts[0]
+            else:
+                continue
+            if mod not in seen:
+                seen.add(mod)
+                tops.append(mod)
+    # Prefer a specific module name over a generic ``environment`` shim if both ship one.
+    tops.sort(key=lambda m: m == "environment")
+    for mod in tops:
+        try:
+            real = importlib.import_module(mod)
+        except Exception:
+            continue
+        if hasattr(real, "load_environment"):
+            _sys.modules.setdefault(expected, real)
+            return
+
+
+def load_verifiers_environment(
+    env_id: str,
+    eval_env_id: str | None = None,
+    eval_examples: int | None = None,
+    eval_seed: int = 12345,
+    **kwargs,
+) -> VerifiersEnvironment:
+    """Load an installed / Hub verifiers environment by id and wrap it for AutoSLM.
+
+    ``env_id`` may be a Hub slug (``owner/name``); it is mapped to the bare verifiers load id.
+    Pass ``eval_env_id`` to evaluate on a *different* Hub env, with ``eval_examples`` /
+    ``eval_seed`` selecting a fixed eval subset. Remaining ``kwargs`` are forwarded to the train
+    env's ``vf.load_environment``.
+    """
+    vf = _import_vf()
+    _ensure_hub_module_importable(vf_load_id(env_id))
+    vf_env = vf.load_environment(vf_load_id(env_id), **_drop_reserved_kwargs(kwargs))
+    eval_ref = eval_env_id
+    if eval_ref:
+        _ensure_hub_module_importable(vf_load_id(eval_ref))
+    eval_vf_env = vf.load_environment(vf_load_id(eval_ref)) if eval_ref else None
+    return VerifiersEnvironment(
+        vf_env,
+        env_id,
+        eval_vf_env=eval_vf_env,
+        eval_examples=eval_examples,
+        eval_seed=eval_seed,
+    )

code/autoslm/envs/base.py

@@ -0,0 +1,49 @@
+"""Small, serializable environment interface for SFT/RL jobs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+
+class Environment(Protocol):
+    id: str
+
+    def dataset(self, split: str) -> list[dict]:
+        """Return the rows for ``split`` (e.g. ``"train"``)."""
+
+    def prompt_messages(self, example: dict) -> list[dict]:
+        """Chat messages fed to the model for one example."""
+
+    def sft_target(self, example: dict) -> str:
+        """Assistant target text for an SFT example."""
+
+    def reward(self, completion: str, example: dict, state: dict | None = None) -> float:
+        """Scalar RL reward for a completion."""
+
+    def grade(self, completion: str, example: dict, state: dict | None = None) -> bool:
+        """Boolean correctness scorer the reward can build on."""
+
+
+@dataclass
+class BaseEnvironment:
+    id: str
+
+    def dataset(self, split: str) -> list[dict]:
+        raise NotImplementedError
+
+    def prompt_messages(self, example: dict) -> list[dict]:
+        question = example.get("question") or example.get("prompt") or ""
+        return [{"role": "user", "content": question}]
+
+    def sft_target(self, example: dict) -> str:
+        return str(example.get("target") or example.get("answer") or "")
+
+    def reward(self, completion: str, example: dict, state: dict | None = None) -> float:
+        return 1.0 if self.grade(completion, example, state) else 0.0
+
+    def grade(self, completion: str, example: dict, state: dict | None = None) -> bool:
+        gold = str(example.get("gold") or example.get("answer") or "").strip()
+        # A missing/empty gold must NOT grade every completion correct (`"" in x` is
+        # always True) — treat it as unscorable -> incorrect.
+        return bool(gold) and gold in (completion or "")

code/autoslm/envs/registry.py

@@ -0,0 +1,95 @@
+"""Environment registry used by specs, worker, CLI, and server.
+
+Verifiers-only: every environment is a Prime Intellect ``verifiers`` env. There are no
+built-in task environments and no local-file environment mode (``schema.py`` rejects a
+``path`` key outright). ``load_environment`` resolves a single source: an installed /
+Prime Hub verifiers env referenced by its slug (``env_id``, ``owner/name``), resolvable
+by ``verifiers`` (installed via ``slm env install owner/name`` and recorded in the
+manifest below).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+from pathlib import Path
+
+from .base import Environment
+
+# Manifest of installed verifiers / Prime Hub environments (written by `slm env install`).
+INSTALLED_MANIFEST = Path(
+    os.environ.get("AUTOSLM_ENVS_MANIFEST", str(Path.home() / ".autoslm" / "envs.json"))
+)
+
+
+def load_installed_manifest() -> dict:
+    try:
+        return json.loads(INSTALLED_MANIFEST.read_text())
+    except (OSError, ValueError):
+        return {}
+
+
+def list_installed_verifiers_envs() -> list[str]:
+    """Names of verifiers/Hub environments installed via `slm env install`."""
+    return sorted(load_installed_manifest())
+
+
+def record_installed_env(env_id: str, package: str, extras: dict | None = None) -> None:
+    manifest = load_installed_manifest()
+    manifest[env_id] = {"package": package, **(extras or {})}
+    INSTALLED_MANIFEST.parent.mkdir(parents=True, exist_ok=True)
+    # The manifest can hold a credentialed --extra-index-url. Create/truncate with 0600
+    # from the start (not write_text + chmod, which leaves it umask-readable in between);
+    # O_NOFOLLOW refuses a symlink planted at the path. chmod after covers a pre-existing
+    # file created before this code path.
+    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC | getattr(os, "O_NOFOLLOW", 0)
+    fd = os.open(INSTALLED_MANIFEST, flags, 0o600)
+    with os.fdopen(fd, "w") as f:
+        json.dump(manifest, f, indent=2, sort_keys=True)
+    with contextlib.suppress(OSError):
+        os.chmod(INSTALLED_MANIFEST, 0o600)
+
+
+def _bare_wheel_name(env_ref: str) -> str:
+    """``owner/name`` Hub slug -> the bare pip wheel name (``name``)."""
+    return env_ref.split("/", 1)[1] if "/" in env_ref else env_ref
+
+
+def worker_pip_for_env(env_id: str) -> list[str]:
+    """Pip deps the GPU worker needs to run ``env_id`` (a verifiers/Hub env): just ``verifiers``.
+
+    The environment itself (and any separate eval env) is installed on the worker via the
+    authenticated ``prime env install`` (see :func:`worker_hub_env_ids`), not pip — the public
+    pip index does not serve private env wheels. Override with ``[environment] pip`` if a run
+    needs extra packages.
+    """
+    return ["verifiers"]
+
+
+def worker_hub_env_ids(env_id: str, params: dict | None = None) -> list[str]:
+    """The Prime Hub env ids the worker must ``prime env install`` for this run.
+
+    The training env plus a separate **eval** Hub env (``[environment.params] eval_env_id``)
+    when configured. ``prime env install`` is authenticated by ``PRIME_API_KEY`` and installs
+    public and private envs alike.
+    """
+    params = params or {}
+    ids = [env_id, params.get("eval_env_id")]
+    return list(dict.fromkeys(str(i) for i in ids if i))
+
+
+def load_environment(env_id: str, params: dict | None = None) -> Environment:
+    """Load a verifiers environment and wrap it in AutoSLM's protocol.
+
+    ``env_id`` is resolved as an installed / Prime Hub verifiers env slug.
+    """
+    params = params or {}
+    from .adapter import load_verifiers_environment
+
+    if not env_id:
+        raise ValueError(
+            "no environment specified: set [environment] id to a verifiers/Prime Hub env "
+            "slug (e.g. 'owner/name')"
+        )
+    return load_verifiers_environment(env_id, **params)

code/autoslm/mcp/__init__.py

@@ -0,0 +1 @@
+"""MCP integration package."""

code/autoslm/mcp/server.py

@@ -0,0 +1,83 @@
+"""Minimal stdio MCP-style bridge for coding agents.
+
+This intentionally avoids a hard dependency on a specific MCP SDK while exposing
+the stable JSON tools that agents need. Requests are newline-delimited JSON:
+{"tool": "list_models", "args": {...}}.
+
+Run-lifecycle tools call the managed AutoSLM control plane with the same stored
+credentials as the CLI (`slm login`); dry-run validation stays local.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Callable
+
+from autoslm.catalog import public_model_rows
+from autoslm.client import client_from_config
+from autoslm.client.specs import spec_payload
+from autoslm.schema import spec_from_dict
+
+
+def list_models(args: dict) -> dict:
+    return {"models": public_model_rows()}
+
+
+def create_train_run(args: dict) -> dict:
+    spec = spec_from_dict(args, run_id=args.get("run_id"))
+    if args.get("dry_run"):
+        # Fully local: validate without credentials, a server, or a GPU.
+        return {"run_id": spec.run_id, "state": "dry_run", "spec": spec.to_dict()}
+    return client_from_config().create_run(spec_payload(spec))
+
+
+def get_run_status(args: dict) -> dict:
+    return client_from_config().get_run(args["run_id"])
+
+
+def get_run_logs(args: dict) -> dict:
+    page = client_from_config().get_logs(args["run_id"], offset=int(args.get("offset", 0)))
+    return {"run_id": args["run_id"], **{k: page[k] for k in ("logs", "offset", "state")}}
+
+
+def deploy_adapter_tool(args: dict) -> dict:
+    return client_from_config().deploy(
+        args["run_id"],
+        mode=args.get("mode", "dev"),
+        idle_timeout_s=int(args.get("idle_timeout_s", 300)),
+        dry_run=bool(args.get("dry_run", False)),
+    )
+
+
+TOOLS: dict[str, Callable[[dict], dict]] = {
+    "list_models": list_models,
+    "create_training_run": create_train_run,
+    "get_run_status": get_run_status,
+    "get_run_logs": get_run_logs,
+    "deploy_adapter": deploy_adapter_tool,
+}
+
+
+def handle(payload: dict) -> dict:
+    tool = payload.get("tool")
+    if tool not in TOOLS:
+        raise ValueError(f"unknown tool {tool!r}; choose one of {sorted(TOOLS)}")
+    return TOOLS[tool](payload.get("args") or {})
+
+
+def main() -> int:
+    for line in sys.stdin:
+        try:
+            line = line.strip()
+            if not line:
+                continue
+            response = {"ok": True, "result": handle(json.loads(line))}
+        except Exception as exc:
+            response = {"ok": False, "error": str(exc)}
+        print(json.dumps(response), flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/autoslm/providers/__init__.py

@@ -0,0 +1,60 @@
+"""Pluggable GPU substrates (RunPod Flash + Vast.ai verified datacenters).
+
+The training worker (``autoslm.engine.worker``) is substrate-neutral — it reads a
+JobSpec from the environment, pulls code from the HF dataset repo, and streams
+artifacts/heartbeats/metrics back to it. Providers differ only in HOW a GPU is priced,
+provisioned, and torn down. Every provider implements the SAME ``base.Provider``
+protocol — that protocol, not the file set, is what makes them interchangeable — and
+each shares a broadly similar module layout (``providers/<name>/{api,auth,pricing,
+gpus,jobs,train,preflight}.py``), with provider-specific additions where needed (e.g.
+``vast/_bootstrap.py``, which has no RunPod analog):
+
+  runpod  serverless Flash endpoints (the original substrate)
+  vast    verified-datacenter instances (REST only)
+
+This module is the registry: ``get_provider(name)`` / ``PROVIDER_NAMES``.
+``allocator.allocate`` is the cross-provider "cheapest GPU that fits" policy that
+iterates every registered provider.
+"""
+
+from __future__ import annotations
+
+from functools import cache
+
+from autoslm.providers.base import Provider
+
+# Registry order is also the tie-break preference (runpod is the longest-validated
+# substrate, so an equal-priced tie prefers it — see allocator.py).
+PROVIDER_NAMES: tuple[str, ...] = ("runpod", "vast")
+
+
+def get_provider(name: str) -> Provider:
+    """The ``Provider`` singleton for a registered name (raises on unknown)."""
+    # Normalize BEFORE the cache so "RunPod"/"runpod"/" runpod " share one cache entry.
+    return _get_provider((name or "").strip().lower())
+
+
+@cache
+def _get_provider(key: str) -> Provider:
+    if key == "runpod":
+        from autoslm.providers.runpod import PROVIDER
+
+        return PROVIDER
+    if key == "vast":
+        from autoslm.providers.vast import PROVIDER
+
+        return PROVIDER
+    raise KeyError(f"unknown provider {key!r} (known: {', '.join(PROVIDER_NAMES)})")
+
+
+def available_providers() -> tuple[str, ...]:
+    """Provider NAMES usable from this control plane right now: a provider is available when it
+    ``is_configured()`` (creds present + net path). RunPod is the always-on default; Vast needs
+    ``VAST_API_KEY`` (and AUTOSLM_SKIP_NET disables both live paths, keeping offline allocation
+    deterministic)."""
+    return tuple(n for n in PROVIDER_NAMES if get_provider(n).is_configured())
+
+
+def configured_providers() -> list[Provider]:
+    """The ``Provider`` objects available right now (see ``available_providers``)."""
+    return [get_provider(n) for n in available_providers()]

code/autoslm/providers/_http.py

@@ -0,0 +1,100 @@
+"""Shared stdlib REST client for the provider API modules.
+
+Both ``providers/runpod/api.py`` and ``providers/vast/api.py`` are thin, no-SDK-state
+clients with the SAME hardened-retry shape: a Bearer/Content-Type urllib request, a
+jittered exponential backoff that retries 5xx/429 and fast-fails other 4xx with the
+response body as the actionable detail, and a "failed after N attempts" raise. They
+differ only in: the env var that holds the key, the error class, and whether the caller
+passes a full URL (RunPod) or a path joined onto a base (Vast). This module factors that
+common core out so the backoff math lives in one place.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import random
+import time
+import urllib.error
+import urllib.request
+from typing import Any
+
+
+class RestClient:
+    """Parametrized urllib REST client with jittered-backoff retries.
+
+    ``base_url`` is prefixed onto the ``target`` passed to each call (empty for the
+    RunPod client, which passes full URLs; the Vast base for the Vast client). The key
+    is read from ``env_var`` on each request (env-only by design — never persisted) and
+    failures raise ``error_cls``.
+    """
+
+    def __init__(
+        self,
+        *,
+        env_var: str,
+        error_cls: type[Exception],
+        base_url: str = "",
+        missing_key_message: str | None = None,
+    ) -> None:
+        self.env_var = env_var
+        self.error_cls = error_cls
+        self.base_url = base_url
+        self.missing_key_message = (
+            missing_key_message or f"{env_var} not configured on the control-plane host"
+        )
+
+    def api_key(self) -> str:
+        key = os.environ.get(self.env_var)
+        if not key:
+            raise self.error_cls(self.missing_key_message)
+        return key
+
+    def request(
+        self, target: str, method: str = "GET", body: dict | None = None, timeout: float = 30.0
+    ) -> Any:
+        req = urllib.request.Request(
+            f"{self.base_url}{target}",
+            method=method,
+            data=json.dumps(body).encode() if body is not None else None,
+            headers={
+                "Authorization": f"Bearer {self.api_key()}",
+                "Content-Type": "application/json",
+            },
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            raw = resp.read()
+            return json.loads(raw) if raw else {}
+
+    def request_with_retries(
+        self,
+        target: str,
+        method: str = "GET",
+        body: dict | None = None,
+        retries: int = 4,
+        base_delay: float = 2.0,
+    ) -> Any:
+        """REST call hardened against transient network/5xx blips (jittered backoff)."""
+        last: Exception | None = None
+        for attempt in range(retries + 1):
+            try:
+                return self.request(target, method=method, body=body)
+            except urllib.error.HTTPError as e:
+                if e.code < 500 and e.code != 429:
+                    # The response body usually carries the actionable error detail; e.reason
+                    # alone (e.g. "Bad Request") is rarely enough to debug a 4xx.
+                    detail = ""
+                    with contextlib.suppress(Exception):
+                        detail = e.read().decode("utf-8", "replace")[:500].strip()
+                    suffix = f": {detail}" if detail else ""
+                    raise self.error_cls(
+                        f"{method} {target} -> HTTP {e.code}: {e.reason}{suffix}"
+                    ) from e
+                last = e
+            except (urllib.error.URLError, TimeoutError, ConnectionError, OSError) as e:
+                last = e
+            if attempt < retries:
+                delay = min(base_delay * (2 ** min(attempt, 6)), 30.0)
+                time.sleep(delay * random.uniform(0.7, 1.3))
+        raise self.error_cls(f"{method} {target} failed after {retries + 1} attempts: {last}")

code/autoslm/providers/_poll.py

@@ -0,0 +1,87 @@
+"""Shared poll-loop scaffolding for the provider job pollers.
+
+``runpod/jobs.py:poll_job`` and ``vast/jobs.py:poll_vast_job`` are independent live
+poll loops with provider-specific terminal-state logic, but they share three verbatim
+blocks: a timestamped ``say()`` logger, a consecutive-poll-error retry/give-up counter,
+and the heartbeat progress-surfacing block (key on (stage, step, ts), log
+``worker: stage=… step=… reward=…``). Only those provider-neutral pieces live here; each
+poller keeps its own status/terminal handling inline.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from typing import Any
+
+
+def make_say(log) -> Callable[[str], None]:
+    """A timestamped line logger that no-ops when ``log`` is None."""
+
+    def say(msg: str) -> None:
+        if log is not None:
+            print(f"[{time.strftime('%H:%M:%S')}] {msg}", file=log, flush=True)
+
+    return say
+
+
+class PollErrorTracker:
+    """Counts consecutive poll errors and decides when to give up.
+
+    Encapsulates the identical retry block both pollers use: on a transient fetch
+    error, log it, give up after ``max_errors`` consecutive failures, otherwise sleep
+    a linear backoff (capped at 60 s) before the caller retries.
+    """
+
+    def __init__(self, say: Callable[[str], None], interval_s: float, max_errors: int = 8) -> None:
+        self._say = say
+        self._interval_s = interval_s
+        self._max_errors = max_errors
+        self._count = 0
+
+    def reset(self) -> None:
+        self._count = 0
+
+    def record(self, exc: Exception) -> bool:
+        """Register a poll error. Returns True if the caller should give up (too many),
+        else sleeps the backoff and returns False (caller should ``continue``)."""
+        self._count += 1
+        self._say(f"poll error ({self._count}): {exc}")
+        if self._count >= self._max_errors:
+            return True
+        time.sleep(min(60, self._interval_s * self._count))
+        return False
+
+
+def surface_heartbeat(
+    heartbeat_reader: Callable[[], Any] | None,
+    last_hb_key: tuple | None,
+    say: Callable[[str], None],
+) -> tuple[tuple | None, str | None]:
+    """Read a heartbeat and, if it advanced, log worker progress.
+
+    Returns ``(hb_key, stage)`` where ``hb_key`` is the new (stage, step, ts) key (or the
+    unchanged ``last_hb_key`` when nothing advanced) and ``stage`` is the stage of the new
+    heartbeat when it advanced (else None). Callers use the returned ``stage`` for their
+    own setup-vs-training stall bookkeeping.
+    """
+    if heartbeat_reader is None:
+        return last_hb_key, None
+    try:
+        hb = heartbeat_reader()
+    except Exception:
+        hb = None
+    if not hb:
+        return last_hb_key, None
+    key = (hb.get("stage"), hb.get("step"), hb.get("ts"))
+    if key == last_hb_key:
+        return last_hb_key, None
+    stage = hb.get("stage")
+    step = hb.get("step")
+    reward = hb.get("reward")
+    say(
+        f"worker: stage={stage}"
+        + (f" step={step}" if step is not None else "")
+        + (f" reward={reward:.3f}" if isinstance(reward, (int, float)) else "")
+    )
+    return key, stage

code/autoslm/providers/allocator.py

@@ -0,0 +1,336 @@
+"""Cross-provider GPU allocation: the cheapest class that comfortably fits the run.
+
+Given a base model (+ algorithm), compute the VRAM the FULL run needs — sized for the
+heavier phase, GRPO, since the typical pipeline is SFT followed by GRPO — then rank
+every provisionable candidate across ALL registered providers by live $/hr and pick the
+cheapest:
+
+  runpod  every Flash-provisionable class (live pricing, cached; static fallback)
+  vast    live verified-datacenter offers (usable_offers' quality floors applied)
+
+Allocation happens at SUBMIT time in the runner (offers are a volatile market);
+the parse-time resolution in schema is a RunPod-static provisional for
+validation/dry-run display. Offline (AUTOSLM_SKIP_NET) the allocator degrades to exactly
+``cheapest_gpu``'s deterministic static-rate answer (RunPod only — Vast is offline-off).
+
+Provider-agnostic by construction: it walks the registered providers and asks each for
+its ``gpu_classes()`` + ``hourly_rate()``; the only provider-specific knowledge is that
+Vast classes come from a live offer book (collected through the provider's
+``usable_offers`` and carried opaquely on ``Candidate.offer``).
+"""
+
+from __future__ import annotations
+
+from autoslm._logging import get_logger
+from autoslm.providers import PROVIDER_NAMES, available_providers, get_provider
+from autoslm.providers.base import (
+    Allocation,
+    Candidate,
+    UnsupportedGpuError,
+    canonical_gpu,
+    unvalidated_allowed,
+)
+
+logger = get_logger(__name__)
+
+# "Comfortably" = the open-model VRAM estimate plus headroom, so a full SFT+GRPO run
+# never lands in check_fit's "tight" band by construction. Curated catalog entries
+# already carry measured minimums and are used as-is. The headroom (default 1.1 ==
+# model_required_vram_gb's own default) is read at call time via vram_headroom() so allocate()
+# and resolve_gpu_policy size identically and pick up a value exported after import.
+
+
+def vram_headroom() -> float:
+    """The sizing headroom multiplier, honored by both the submit-time allocator and the
+    parse-time resolve_gpu_policy so they never disagree (PR #176 review). A validated constant."""
+    return 1.1
+
+
+def required_vram_gb(
+    model_id: str,
+    algorithm: str,
+    *,
+    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.
+
+    Catalog GRPO floors stay hard floors (never under-provision a validated model); the
+    matrix sizes up from there for big contexts/groups and down to a cheaper card for
+    small runs. Unlisted open models size from HF metadata, falling back to the 24 GB tier
+    when unreadable (handled inside model_required_vram_gb)."""
+    from autoslm.engine.vram import 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]:
+    """RunPod's fitting classes priced live (static fallback)."""
+    provider = get_provider("runpod")
+    out: list[Candidate] = []
+    for g in provider.gpu_classes():
+        if g.vram_gb < need:
+            continue
+        if pinned_gpu and g.name != pinned_gpu:
+            continue
+        if "runpod" not in g.validated_on and not allow_unval:
+            continue
+        out.append(
+            Candidate(
+                "runpod",
+                g.name,
+                provider.hourly_rate(g.name),
+                g.vram_gb,
+                "runpod" in g.validated_on,
+            )
+        )
+    return out
+
+
+def _vast_candidates(
+    need: int,
+    pinned_gpu: str | None,
+    allow_unval: bool,
+    disk_gb: int,
+    exclude_machine_ids,
+    *,
+    required: bool,
+    num_gpus: int = 1,
+) -> tuple[list[Candidate], tuple]:
+    """Vast's fitting classes from the live offer book (cheapest per class).
+
+    Returns (candidates, full_offer_book). ``required`` (a hard ``provider="vast"``
+    pin) re-raises a search failure; otherwise it degrades to RunPod-only.
+    """
+    from autoslm.providers.base import GPU_INFO
+    from autoslm.providers.vast.jobs import MIN_DISK_GB, usable_offers
+
+    # When a larger class is pinned for a small model, search at the PINNED class's VRAM,
+    # not the (smaller) model requirement: the offer search returns the cheapest ``limit``
+    # offers from a VRAM floor, so a search at ``need`` can fill that window entirely with
+    # small cheap cards and never surface the pinned larger class. ``need`` is still the
+    # validity floor (allocate() rejects an undersized pin before we get here).
+    search_vram = max(need, GPU_INFO[pinned_gpu].vram_gb) if pinned_gpu else need
+    book: list = []
+    try:
+        # The offer search must use the SAME disk floor instances are actually
+        # provisioned with (``create_instance``/``_effective_disk_gb``); searching at a
+        # smaller requested ``disk_gb`` would surface offers that then fail to rent.
+        book = usable_offers(
+            search_vram, max(float(disk_gb), MIN_DISK_GB),
+            exclude_machine_ids=exclude_machine_ids, num_gpus=num_gpus,
+        )
+    except Exception as exc:
+        if required:
+            raise UnsupportedGpuError(f"vast offer search failed: {exc}") from exc
+        logger.warning("vast offer search failed (%s); allocating on runpod only", exc)
+    out: list[Candidate] = []
+    seen: set[str] = set()
+    for o in book:
+        if pinned_gpu and o.gpu != pinned_gpu:
+            continue
+        info = GPU_INFO[o.gpu]
+        if "vast" not in info.validated_on and not allow_unval:
+            continue
+        if o.gpu in seen:  # offers are price-sorted; keep the cheapest per class
+            continue
+        seen.add(o.gpu)
+        out.append(
+            Candidate(
+                "vast", o.gpu, o.dph_total, info.vram_gb, "vast" in info.validated_on, offer=o
+            )
+        )
+    return out, tuple(book)
+
+
+def allocate(
+    model_id: str,
+    algorithm: str,
+    *,
+    gpu: str | None = None,
+    provider: str = "auto",
+    disk_gb: int = 60,
+    allow_unvalidated: bool | None = None,
+    exclude_machine_ids: set[int] | frozenset[int] = frozenset(),
+    exclude_gpu_classes: set[str] | frozenset[str] = frozenset(),
+    gpu_count: int = 1,
+    train=None,
+    thinking: bool = False,
+) -> Allocation:
+    """Pick the cheapest (provider, GPU class) able to run the job across providers.
+
+    ``gpu`` pins the class (the allocator then only picks the provider); ``provider``
+    pins the substrate ("auto"/"runpod"/"vast"). Both default to fully automatic.
+    ``train``/``thinking`` size the requirement to the run's actual knobs (context, group,
+    rank, batch) via the matrix — long context / large group route up, small runs down.
+    ``exclude_gpu_classes`` drops whole GPU classes (any provider) from the candidate pool —
+    the orchestrator adds a class here after it failed ``no_capacity`` (capacity-starved /
+    throttled) so re-allocation walks to the next-cheapest AVAILABLE class instead of retrying
+    the same starved one on another provider.
+    """
+    _excluded_classes = {canonical_gpu(c) for c in exclude_gpu_classes}
+    if provider not in ("auto", *PROVIDER_NAMES):
+        raise UnsupportedGpuError(
+            f"unknown provider {provider!r} (auto, {', '.join(PROVIDER_NAMES)})"
+        )
+    pinned_gpu = canonical_gpu(gpu) if gpu else None
+    # The model's requirement is the floor regardless of a pin: an undersized concrete
+    # 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, gpu_count=gpu_count)
+    allow_unval = unvalidated_allowed(allow_unvalidated)
+    live = available_providers()
+    if provider != "auto" and provider not in live:
+        raise UnsupportedGpuError(
+            f"provider {provider!r} requested but not available on this control plane "
+            f"(available: {', '.join(live) or '(none)'}; vast needs VAST_API_KEY)"
+        )
+
+    def _gather(pin: str | None) -> tuple[list[Candidate], tuple]:
+        cands: list[Candidate] = []
+        book: tuple = ()
+        if provider in ("auto", "runpod") and "runpod" in live:
+            cands += _runpod_candidates(need, pin, allow_unval)
+        if provider in ("auto", "vast") and "vast" in live:
+            vcands, book = _vast_candidates(
+                need, pin, allow_unval, disk_gb, exclude_machine_ids,
+                required=(provider == "vast"), num_gpus=gpu_count,
+            )
+            cands += vcands
+        if _excluded_classes:
+            cands = [c for c in cands if c.gpu not in _excluded_classes]
+        return cands, book
+
+    candidates, offer_book = _gather(pinned_gpu)
+    # NEVER hard-fail on availability: a pin that no live provider can serve (the class isn't
+    # offered right now, or is below ``need`` so it's filtered out) escalates to the cheapest
+    # FITTING class across providers instead of raising -- "one spot larger, and so on". The
+    # ``need`` floor is still absolute (we never drop below it -> no OOM), and the pin is only a
+    # preference. We only raise when NOTHING >= need is available anywhere (truly unsatisfiable).
+    escalated_from = None
+    if not candidates and pinned_gpu is not None:
+        escalated_from = pinned_gpu
+        candidates, offer_book = _gather(None)
+    if not candidates:
+        raise UnsupportedGpuError(
+            f"no allocatable GPU (>= {need} GB VRAM for {model_id}, provider={provider}, "
+            f"validated_only={not allow_unval}); widen with gpu.allow_unvalidated = true, add a "
+            f"provider (VAST_API_KEY), or the run genuinely exceeds every available GPU class"
+        )
+    if escalated_from is not None:
+        order0 = {n: i for i, n in enumerate(PROVIDER_NAMES)}
+        _cheapest = sorted(candidates, key=lambda c: (c.hourly_usd, c.vram_gb, order0.get(c.provider, 99)))[0]
+        # WARNING level so it surfaces at default `slm train` verbosity (configure_logging is
+        # WARNING) — a silently-escalated pin changes cost/hardware and operators must see it;
+        # still routed through the logger (stderr), so machine-readable stdout stays clean.
+        logger.warning(
+            "pinned GPU %r unavailable or below need (%s GB) on provider=%s; "
+            "escalated to cheapest fitting class %s (%s GB, %s)",
+            escalated_from,
+            need,
+            provider,
+            _cheapest.gpu,
+            _cheapest.vram_gb,
+            _cheapest.provider,
+        )
+    # Cheapest first; equal rates prefer less VRAM (don't burn a big card on a small
+    # job), then registry order (runpod is the longest-validated substrate).
+    order = {n: i for i, n in enumerate(PROVIDER_NAMES)}
+    ranked = sorted(candidates, key=lambda c: (c.hourly_usd, c.vram_gb, order.get(c.provider, 99)))
+    best = ranked[0]
+    return Allocation(
+        provider=best.provider,
+        gpu=best.gpu,
+        hourly_usd=best.hourly_usd,
+        min_vram_gb=need,
+        candidates=tuple(ranked),
+        offer=best.offer,
+        provider_offers=offer_book,
+    )
+
+
+def allocation_summary(a: Allocation) -> str:
+    head = (
+        f"allocated {a.gpu} on {a.provider} at ${a.hourly_usd:.2f}/hr "
+        f"(need >= {a.min_vram_gb} GB VRAM"
+    )
+    # ``a.offer`` is an OPAQUE per-provider provisioning hint, not necessarily a Vast
+    # offer — only format Vast specifics when the chosen provider is vast, so a future
+    # provider's hint never misformats or raises on a missing attribute.
+    if a.provider == "vast" and a.offer is not None:
+        head += f", vast offer {a.offer.offer_id} in {a.offer.geolocation}"
+    head += ")"
+    if len(a.candidates) > 1:
+        nxt = a.candidates[1]
+        head += f"; next-best: {nxt.gpu}@{nxt.provider} ${nxt.hourly_usd:.2f}/hr"
+    return head

code/autoslm/providers/base.py

@@ -0,0 +1,549 @@
+"""Shared GPU-provider interface + the provider-agnostic GPU registry.
+
+Both substrates (RunPod Flash, Vast.ai verified datacenters) implement the SAME
+``Provider`` protocol and expose the SAME module set under ``providers/<name>/`` so a
+provider is pluggable/swappable. This module owns the parts that are NOT provider
+specific:
+
+  * ``GpuClass`` — one managed GPU class with its per-provider identity
+    (``enum_member`` for RunPod, ``vast_name`` for Vast) and per-provider
+    ``validated_on``. Each provider owns *which* classes it lists (its ``gpus.py``
+    carves its rows out of ``GPU_CLASSES``), but the class table itself is shared so a
+    friendly name canonicalizes to one identity everywhere (catalog, config, serving).
+  * ``JobHandle`` / ``PollResult`` — the persisted-handle + poll-outcome shapes the
+    orchestrator round-trips through any provider.
+  * ``Candidate`` / ``Allocation`` — the cross-provider allocation result.
+  * The canonicalization / alias / policy helpers every call site already used.
+
+The ``Provider`` protocol is the FIXED method set both providers implement; the
+orchestrator dispatches cancel/poll/destroy generically through the persisted
+handle's ``provider`` key. The post-run GC backstop is the deliberate exception:
+RunPod's ``gc`` runs unconditionally (a name-reconstruction backstop for rN-suffixed
+endpoints the persisted handle can't name) and Vast's ``gc`` is called by name only
+when Vast is available (its billing-leak reap), so that path branches per provider.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from autoslm.spec import JobSpec
+
+
+# ---------------------------------------------------------------------------
+# GPU class registry (provider-agnostic identity + per-provider validation)
+# ---------------------------------------------------------------------------
+@dataclass(frozen=True)
+class GpuClass:
+    """One managed GPU class: a friendly name + per-provider identity/metadata.
+
+    Provider-agnostic by design — the identity columns (``enum_member`` for RunPod's
+    Flash ``GpuType``; ``vast_name`` for the Vast offer ``gpu_name``) and
+    ``validated_on`` carry the per-provider facts, but a class is a single canonical
+    row so the catalog / config / serving all agree on what e.g. "RTX 5090" is.
+    """
+
+    name: str  # canonical friendly name used in configs / the catalog
+    enum_member: str | None  # runpod_flash GpuType member name; None -> not on RunPod
+    vram_gb: int
+    short: str  # endpoint-name-safe token (e.g. "4090", "a5000")
+    sm: str  # CUDA arch (informational; sm80+ only)
+    hourly_usd: float  # static fallback rate; live pricing overrides (pricing.py)
+    # Providers where this class passed AutoSLM's live train+eval smoke. Validation is
+    # per-provider: the same silicon behind a different provisioning path (Flash deps
+    # install vs a Vast docker image) is a different failure surface.
+    validated_on: tuple[str, ...] = ()
+    # Min host CUDA (driver) on the modern stack. None -> 12.8. Blackwell (sm120/sm100)
+    # needs CUDA-13 drivers to JIT the wheels' PTX (no SASS shipped).
+    min_cuda_modern: str | None = None
+    # Vast.ai offer ``gpu_name`` for this class; None -> not provisionable on Vast.
+    # A100 SXM4 boards exist in 40 GB and 80 GB variants under ONE Vast name — offers
+    # are disambiguated by ``gpu_ram`` (see ``vast_gpu_for_offer``).
+    vast_name: str | None = None
+
+    @property
+    def validated(self) -> bool:  # validated on ANY provider
+        return bool(self.validated_on)
+
+
+# Fallback hourly rates are RunPod secure-cloud on-demand (snapshot 2026-06-11); live
+# rates from the provider pricing module override them. Vast-only classes
+# (enum_member=None) carry a Vast verified-datacenter snapshot instead.
+GPU_CLASSES: tuple[GpuClass, ...] = (
+    # ---- validated: passed the full train+eval matrix (bench/results/phase1) ----
+    GpuClass(
+        "RTX 4090",
+        "NVIDIA_GEFORCE_RTX_4090",
+        24,
+        "4090",
+        "sm89",
+        0.69,
+        validated_on=("runpod",),
+        vast_name="RTX 4090",
+    ),
+    # Vast-validated 2026-06-12: Qwen3-0.6B SFT train+eval smoke on a verified
+    # datacenter ($0.60/hr South Korea), incl. vLLM eval on a CUDA-13 driver.
+    GpuClass(
+        "RTX 5090",
+        "NVIDIA_GEFORCE_RTX_5090",
+        32,
+        "5090",
+        "sm120",
+        0.99,
+        validated_on=("runpod", "vast"),
+        min_cuda_modern="13.0",
+        vast_name="RTX 5090",
+    ),
+    # ---- Ampere/Ada workstation + datacenter cards (cheap capacity pools) ----
+    GpuClass("RTX A4000", "NVIDIA_RTX_A4000", 16, "a4000", "sm86", 0.25, vast_name="RTX A4000"),
+    GpuClass(
+        "RTX 2000 Ada",
+        "NVIDIA_RTX_2000_ADA_GENERATION",
+        16,
+        "2000ada",
+        "sm89",
+        0.24,
+        vast_name="RTX 2000Ada",
+    ),
+    GpuClass("RTX A4500", "NVIDIA_RTX_A4500", 20, "a4500", "sm86", 0.25, vast_name="RTX A4500"),
+    GpuClass(
+        "RTX 4000 Ada",
+        "NVIDIA_RTX_4000_ADA_GENERATION",
+        20,
+        "4000ada",
+        "sm89",
+        0.26,
+        vast_name="RTX 4000Ada",
+    ),
+    # Validated 2026-06-11: Qwen3-0.6B SFT + GRPO smokes passed — cheapest 24 GB class.
+    GpuClass(
+        "RTX A5000",
+        "NVIDIA_RTX_A5000",
+        24,
+        "a5000",
+        "sm86",
+        0.27,
+        validated_on=("runpod",),
+        vast_name="RTX A5000",
+    ),
+    # Vast-validated 2026-06-12: Qwen3-0.6B SFT train+eval smoke ($0.25/hr Czechia).
+    GpuClass(
+        "RTX 3090",
+        "NVIDIA_GEFORCE_RTX_3090",
+        24,
+        "3090",
+        "sm86",
+        0.46,
+        validated_on=("vast",),
+        vast_name="RTX 3090",
+    ),
+    GpuClass("L4", "NVIDIA_L4", 24, "l4", "sm89", 0.39, vast_name="L4"),
+    # Blackwell workstation card; cheap verified-datacenter capacity on Vast.
+    # Vast-validated 2026-06-12: Qwen3-0.6B SFT train+eval smoke incl. vLLM eval on a
+    # CUDA-13 driver with the cu128 stack image ($0.34/hr Hungary). Vast-only.
+    GpuClass(
+        "RTX Pro 4000",
+        None,
+        24,
+        "pro4000",
+        "sm120",
+        0.34,
+        validated_on=("vast",),
+        min_cuda_modern="13.0",
+        vast_name="RTX PRO 4000",
+    ),
+    GpuClass("RTX A6000", "NVIDIA_RTX_A6000", 48, "a6000", "sm86", 0.49, vast_name="RTX A6000"),
+    GpuClass("A40", "NVIDIA_A40", 48, "a40", "sm86", 0.44, vast_name="A40"),
+    GpuClass(
+        "RTX 6000 Ada",
+        "NVIDIA_RTX_6000_ADA_GENERATION",
+        48,
+        "6000ada",
+        "sm89",
+        0.77,
+        vast_name="RTX 6000Ada",
+    ),
+    # L40S exists at RunPod but not in the Flash SDK's GpuType enum -> Vast-only.
+    GpuClass("L40S", None, 48, "l40s", "sm89", 0.87, vast_name="L40S"),
+    # ---- big-VRAM tier (large-MoE QLoRA, future >9B bf16) ----
+    # 40 GB SXM4 boards share Vast's "A100 SXM4" name with the 80 GB variant; offers
+    # are split by gpu_ram (vast_gpu_for_offer). Not a RunPod Flash class -> Vast-only.
+    GpuClass("A100 SXM 40GB", None, 40, "a100sxm40", "sm80", 0.89, vast_name="A100 SXM4"),
+    # Validated 2026-06-11: 0.6B SFT smoke (phase6).
+    GpuClass(
+        "A100 PCIe",
+        "NVIDIA_A100_80GB_PCIe",
+        80,
+        "a100pcie",
+        "sm80",
+        1.39,
+        validated_on=("runpod",),
+        vast_name="A100 PCIE",
+    ),
+    GpuClass(
+        "A100 SXM", "NVIDIA_A100_SXM4_80GB", 80, "a100sxm", "sm80", 1.49, vast_name="A100 SXM4"
+    ),
+    GpuClass("H100", "NVIDIA_H100_80GB_HBM3", 80, "h100", "sm90", 3.29, vast_name="H100 SXM"),
+    # H100 NVL (94 GB) has no RunPod Flash GpuType member -> Vast-only. Cheaper than the
+    # 80 GB SXM H100 on the live market and carries 14 GB more VRAM, so it's a strong
+    # cost/VRAM pick for big-context GRPO tiers.
+    GpuClass(
+        "H100 NVL", None, 94, "h100nvl", "sm90", 2.39, validated_on=("vast",), vast_name="H100 NVL"
+    ),
+    GpuClass(
+        "RTX Pro 6000",
+        "NVIDIA_RTX_PRO_6000_BLACKWELL_SERVER_EDITION",
+        96,
+        "pro6000",
+        "sm120",
+        2.09,
+        min_cuda_modern="13.0",
+    ),
+    # RTX Pro 6000 Blackwell Workstation Edition: same 96 GB die as the Server Edition,
+    # a distinct RunPod GpuType, typically a touch cheaper. Also offered on Vast. The
+    # single biggest non-datacenter 96 GB option -> cheapest 80 GB-floor GRPO host.
+    GpuClass(
+        "RTX Pro 6000 WK",
+        "NVIDIA_RTX_PRO_6000_BLACKWELL_WORKSTATION_EDITION",
+        96,
+        "pro6000wk",
+        "sm120",
+        1.79,
+        validated_on=("runpod", "vast"),
+        min_cuda_modern="13.0",
+        vast_name="RTX PRO 6000",
+    ),
+)
+
+GPU_INFO: dict[str, GpuClass] = {g.name: g for g in GPU_CLASSES}
+
+# Canonical friendly names AutoSLM exposes in configs / the catalog.
+KNOWN = tuple(GPU_INFO)
+# Classes proven by a live train+eval smoke (the default selection pool).
+SUPPORTED = tuple(g.name for g in GPU_INFO.values() if g.validated)
+
+# GPU-policy keywords accepted in ``gpu.type`` (resolved to a concrete class at parse
+# time by ``resolve_gpu_policy``; the submit-time allocator re-resolves them live).
+POLICY_NAMES = ("cheapest", "auto")
+
+
+def _alias_keys(name: str) -> set[str]:
+    """All accepted spellings of a friendly name (lowercased)."""
+    base = name.lower()
+    keys = {base, base.replace(" ", ""), base.replace(" ", "_"), base.replace(" ", "-")}
+    if base.startswith("rtx "):
+        tail = base[4:]
+        keys |= {tail, tail.replace(" ", ""), tail.replace(" ", "_")}
+    keys.add(f"nvidia {base}")
+    return keys
+
+
+_ALIASES: dict[str, str] = {}
+for _info in GPU_INFO.values():
+    for _k in _alias_keys(_info.name):
+        _ALIASES[_k] = _info.name
+# Spellings that don't fall out of the generic rules: full marketing names (what
+# nvidia-smi / the RunPod API print) and historical AutoSLM aliases.
+_ALIASES.update(
+    {
+        "nvidia geforce rtx 4090": "RTX 4090",
+        "nvidia geforce rtx 5090": "RTX 5090",
+        "nvidia geforce rtx 3090": "RTX 3090",
+        "nvidia l4": "L4",
+        "nvidia a40": "A40",
+        "nvidia rtx 6000 ada generation": "RTX 6000 Ada",
+        "rtx 6000 ada generation": "RTX 6000 Ada",
+        "nvidia rtx 4000 ada generation": "RTX 4000 Ada",
+        "nvidia rtx 2000 ada generation": "RTX 2000 Ada",
+        "nvidia a100 80gb pcie": "A100 PCIe",
+        "a100 80gb pcie": "A100 PCIe",
+        "a100-80g-pcie": "A100 PCIe",
+        "nvidia a100-sxm4-80gb": "A100 SXM",
+        "a100-sxm4-80gb": "A100 SXM",
+        "a100": "A100 PCIe",
+        "nvidia h100 80gb hbm3": "H100",
+        "h100 80gb hbm3": "H100",
+        "rtx pro 6000 blackwell": "RTX Pro 6000",
+        "nvidia rtx pro 6000 blackwell server edition": "RTX Pro 6000",
+    }
+)
+
+
+class UnsupportedGpuError(ValueError):
+    pass
+
+
+def canonical_gpu(name: str) -> str:
+    """Normalize a friendly GPU name to one of ``KNOWN``; raise otherwise."""
+    key = (name or "").strip().lower()
+    if key in _ALIASES:
+        return _ALIASES[key]
+    raise UnsupportedGpuError(
+        f'unsupported gpu {name!r}; AutoSLM manages {", ".join(KNOWN)} (or gpu.type = "cheapest")'
+    )
+
+
+def get_gpu_info(name: str) -> GpuClass:
+    return GPU_INFO[canonical_gpu(name)]
+
+
+def is_validated(name: str, provider: str | None = None) -> bool:
+    """Validated on ``provider`` (when given) or on any provider (provider=None)."""
+    info = get_gpu_info(name)
+    if provider is None or provider == "auto":
+        return info.validated
+    return provider in info.validated_on
+
+
+def providers_for(name: str) -> tuple[str, ...]:
+    """Providers that can provision this GPU class."""
+    info = get_gpu_info(name)
+    out = []
+    if info.enum_member:
+        out.append("runpod")
+    if info.vast_name:
+        out.append("vast")
+    return tuple(out)
+
+
+# Boards under-report usable VRAM vs the class's nominal size (measured live: L4
+# offers carry 23034 MB for the 24 GB class, A40 offers 46068 MB for the 48 GB
+# class — ~3 GB under), so class matching gets a tolerance. Safe at 3.5 GB: names
+# shared across VRAM variants differ by >= 40 GB (A100 SXM4 40/80).
+_VRAM_MATCH_TOLERANCE_GB = 3.5
+
+
+def vast_gpu_for_offer(gpu_name: str, gpu_ram_mb: float) -> str | None:
+    """Map a Vast offer (``gpu_name`` + ``gpu_ram`` MB) to a canonical GPU class.
+
+    Returns None for anything not in the managed table — that's the hard Ampere+
+    floor (T4/2080 Ti/Quadro RTX offers never match). Names shared across VRAM
+    variants (A100 SXM4 40/80 GB) resolve to the largest class the board's actual
+    RAM covers.
+    """
+    fitting = [
+        g
+        for g in GPU_INFO.values()
+        if g.vast_name == gpu_name and g.vram_gb <= gpu_ram_mb / 1024 + _VRAM_MATCH_TOLERANCE_GB
+    ]
+    if not fitting:
+        return None
+    return max(fitting, key=lambda g: g.vram_gb).name
+
+
+def unvalidated_allowed(explicit: bool | None = None) -> bool:
+    """Whether configs may target a non-``validated`` GPU class."""
+    if explicit is not None:
+        return explicit
+    # Truthy allowlist (not a falsey denylist): only an explicit truthy value opts in, so
+    # "false"/"False"/"no"/"off"/"0"/"" all correctly leave unvalidated GPUs disabled.
+    return os.environ.get("AUTOSLM_GPU_ALLOW_UNVALIDATED", "").strip().lower() in (
+        "1",
+        "true",
+        "yes",
+        "on",
+    )
+
+
+def gpu_short(name: str) -> str:
+    """Short, endpoint-name-safe token for a GPU (e.g. '4090')."""
+    return get_gpu_info(name).short
+
+
+def min_cuda_modern(name: str) -> str:
+    """Minimum host CUDA (driver) version for this GPU class on the modern stack."""
+    return get_gpu_info(name).min_cuda_modern or "12.8"
+
+
+def cheapest_gpu(min_vram_gb: int, include_unvalidated: bool = False) -> str:
+    """Cheapest RunPod GPU class with at least ``min_vram_gb`` VRAM (live rates, cached).
+
+    RunPod-static by design (the cross-provider equivalent lives in
+    ``autoslm.providers.allocator``): Vast-only classes are excluded so the result is
+    always deployable via Flash, and offline resolution stays deterministic.
+    """
+    pool = [
+        g
+        for g in GPU_INFO.values()
+        if g.enum_member
+        and g.vram_gb >= min_vram_gb
+        and (include_unvalidated or "runpod" in g.validated_on)
+    ]
+    if not pool:
+        raise UnsupportedGpuError(
+            f"no {'known' if include_unvalidated else 'validated'} GPU has >= {min_vram_gb} GB VRAM"
+        )
+    from autoslm.providers.runpod.pricing import hourly_rate
+
+    return min(pool, key=lambda g: (hourly_rate(g.name), g.vram_gb)).name
+
+
+def resolve_gpu_policy(
+    requested: str,
+    model_id: str,
+    allow_unvalidated: bool | None = None,
+    algorithm: str = "sft",
+    *,
+    train=None,
+    thinking: bool = False,
+) -> str:
+    """Resolve ``gpu.type`` (a concrete class or a policy word) to a friendly name.
+
+    Parse-time, RunPod-static provisional: "cheapest"/"auto" pick the cheapest
+    RunPod-validated class whose VRAM covers the model; concrete names are
+    canonicalized. The submit-time allocator (``autoslm.providers.allocator``)
+    re-resolves policy words live across providers.
+    """
+    key = (requested or "").strip().lower()
+    if key not in POLICY_NAMES:
+        return canonical_gpu(requested)
+    from autoslm.engine.vram import model_required_vram_gb
+    from autoslm.providers.allocator import vram_headroom
+
+    # Honor AUTOSLM_VRAM_HEADROOM here too so parse-time sizing matches the submit-time
+    # allocator exactly (PR #176 review: they previously diverged on the headroom knob).
+    min_vram = model_required_vram_gb(
+        model_id, algorithm, train=train, thinking=thinking, headroom=vram_headroom()
+    )
+    return cheapest_gpu(min_vram, include_unvalidated=unvalidated_allowed(allow_unvalidated))
+
+
+# ---------------------------------------------------------------------------
+# Handles + poll outcomes (round-tripped through any provider)
+# ---------------------------------------------------------------------------
+@dataclass
+class JobHandle:
+    """Provider-tagged, persisted handle: enough to reattach/cancel from any process.
+
+    Each provider owns the rest of its handle shape (RunPod: endpoint_id/job_id; Vast:
+    instance_id/offer_id/...). ``provider`` is the routing key the orchestrator uses to
+    dispatch poll/cancel/destroy generically through the registry.
+    """
+
+    provider: str
+    data: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {"provider": self.provider, **self.data}
+
+    @classmethod
+    def from_dict(cls, d: dict) -> JobHandle:
+        d = dict(d)
+        provider = d.pop("provider", "runpod")
+        return cls(provider=provider, data=d)
+
+
+@dataclass
+class PollResult:
+    ok: bool
+    metrics: dict | None = None
+    failure: str | None = None  # "job_failed" | "stalled" | "poll_error"
+    detail: str | None = None
+
+
+# ---------------------------------------------------------------------------
+# Allocation result (cross-provider)
+# ---------------------------------------------------------------------------
+@dataclass(frozen=True)
+class Candidate:
+    provider: str
+    gpu: str
+    hourly_usd: float
+    vram_gb: int
+    validated: bool
+    # Opaque per-provider provisioning hint (e.g. the chosen Vast offer). The
+    # allocator stays provider-agnostic; the provider interprets it at submit time.
+    offer: Any = None
+
+
+@dataclass(frozen=True)
+class Allocation:
+    provider: str
+    gpu: str
+    hourly_usd: float
+    min_vram_gb: int
+    candidates: tuple[Candidate, ...]  # full ranked list (retry walks this)
+    offer: Any = None  # the chosen provider's provisioning hint (vast offer | None)
+    # Per-provider book of provisioning hints for the live-market walk (vast offers).
+    provider_offers: tuple[Any, ...] = ()
+
+
+# ---------------------------------------------------------------------------
+# The provider interface (FIXED method set both providers implement)
+# ---------------------------------------------------------------------------
+@runtime_checkable
+class Provider(Protocol):
+    """The pluggable GPU-substrate interface.
+
+    Both ``providers/runpod`` and ``providers/vast`` expose ``PROVIDER`` implementing
+    this protocol with an identical module layout (api/auth/pricing/gpus/jobs/
+    train/preflight). The orchestrator/allocator only ever talk to these methods, so a
+    provider is swappable without touching the control plane.
+    """
+
+    name: str
+
+    def is_configured(self) -> bool:
+        """Whether this provider is usable right now (creds present, net reachable)."""
+        ...
+
+    def preflight(self, require_hf: bool = True) -> list[str]:
+        """Missing-config problems (empty list == ready). The control plane aggregates
+        these into one fail-fast error at startup."""
+        ...
+
+    def gpu_classes(self) -> list[GpuClass]:
+        """The GPU classes this provider can provision (its rows of the shared table)."""
+        ...
+
+    def hourly_rate(self, gpu: str) -> float:
+        """$/hr for one friendly GPU name (live if available, else static)."""
+        ...
+
+    def submit_run(
+        self,
+        spec: JobSpec,
+        seed: int,
+        *,
+        log: Any = None,
+        on_handle: Any = None,
+        attempt: int = 0,
+        offers: Any = None,
+        exclude_machine_ids: Any = frozenset(),
+    ) -> PollResult:
+        """Deploy/rent -> submit -> persist handle (via ``on_handle``) -> poll.
+
+        ``exclude_machine_ids`` is the run's blacklist (machines that already failed
+        this run); a provider that re-searches the live market mid-submit (Vast) must
+        keep them excluded so a stalled/sick machine is never re-picked. RunPod ignores
+        it (no in-provider market re-search)."""
+        ...
+
+    def poll(self, handle: JobHandle, spec: JobSpec, seed: int, *, log: Any = None) -> PollResult:
+        """Reattach to a persisted handle and poll it to a terminal state."""
+        ...
+
+    def cancel(self, handle: JobHandle) -> None:
+        """Stop the exact remote worker for this handle (cross-process)."""
+        ...
+
+    def destroy(self, handle: JobHandle) -> None:
+        """Tear down the billable resource this handle owns (idempotent)."""
+        ...
+
+    def gc(self, spec: JobSpec) -> None:
+        """Best-effort: reap any resource this run may have left registered."""
+        ...
+
+    def sweep_orphans(self, active_labels: set[str] | None = None) -> list[int]:
+        """Destroy any billable resource this provider owns that no live run claims.
+
+        Crash recovery: run at server startup (and after runs). ``active_labels`` is the
+        set of instance-label PREFIXES still owned by recoverable runs — anything this
+        provider rented that matches none of them is an orphan. Returns the destroyed
+        resource ids. Providers without a standing-billing substrate (RunPod's
+        serverless endpoints self-reap) implement this as a no-op."""
+        ...

code/autoslm/providers/preflight.py

@@ -0,0 +1,80 @@
+"""Cross-provider startup preflight.
+
+``check_run_preflight`` aggregates EVERY selected provider's missing-config problems
+(RunPod is the default substrate; Vast only when configured/pinned) plus the shared
+Hugging Face dataset-repo requirements, so a single startup error lists everything
+missing. The per-provider key checks live in ``autoslm.providers.<name>.preflight``.
+"""
+
+from __future__ import annotations
+
+import os
+
+from autoslm.providers.runpod.preflight import (
+    PreflightError,
+    missing_credentials,
+)
+
+__all__ = [
+    "PreflightError",
+    "check_run_preflight",
+]
+
+
+def _missing_hf_credentials() -> list[str]:
+    """Shared run infra every substrate needs: the HF write token, plus PRIME_API_KEY (the
+    worker ``prime env install``s the run's Hub env regardless of the GPU provider). The HF
+    dataset repo is per-run (``[train] hf_repo``), not an operator var."""
+    problems: list[str] = []
+    if not os.environ.get("PRIME_API_KEY"):
+        problems.append(
+            "  - PRIME_API_KEY: a Prime Intellect API key; the GPU worker uses it to "
+            "`prime env install` the run's Hub environment (public + private), e.g. "
+            "`export PRIME_API_KEY=pit_...`"
+        )
+    if not os.environ.get("HF_TOKEN"):
+        problems.append(
+            "  - HF_TOKEN: a token with write access to each run's "
+            "`[train] hf_repo`, e.g. `export HF_TOKEN=hf_...`"
+        )
+    return problems
+
+
+def _preflight_provider_names() -> set[str]:
+    """The providers whose operator config this control plane must satisfy. RunPod is always
+    required (the default substrate); Vast is opt-in (preflighted only when VAST_API_KEY signals
+    intent)."""
+    names = {"runpod"}  # always-on default substrate
+    if os.environ.get("VAST_API_KEY"):
+        names.add("vast")  # opt-in: a partial vast config signals intent
+    return names
+
+
+def check_run_preflight(require_hf: bool = True) -> None:
+    """Validate operator config across the configured providers; raise on missing.
+
+    Only the providers this control plane actually uses are checked: RunPod's requirements
+    (RUNPOD_API_KEY + the shared PRIME_API_KEY/HF_TOKEN) are always checked, and a configured
+    Vast key (VAST_API_KEY) adds its own check. The HF dataset repo is per-run
+    (``[train] hf_repo``), not an operator var.
+    """
+    selected = _preflight_provider_names()
+    problems: list[str] = []
+    # The HF write token is SHARED run infra (every substrate streams artifacts through HF),
+    # so it is checked once regardless of which providers are selected — a Vast-only plane
+    # still needs it. Each provider check is asked for its keys only (require_hf=False) so HF
+    # isn't double-reported. The HF dataset repo itself is per-run (``[train] hf_repo``).
+    if "runpod" in selected:
+        problems += missing_credentials(require_hf=False)
+    if "vast" in selected:
+        from autoslm.providers.vast.preflight import missing_credentials as vast_missing
+
+        problems += vast_missing(require_hf=False)
+    if require_hf:
+        problems += _missing_hf_credentials()
+    if problems:
+        raise PreflightError(
+            "the AutoSLM control plane is missing required operator configuration:\n"
+            + "\n".join(problems)
+            + "\n\nSet these on the control-plane host."
+        )

code/autoslm/providers/runpod/__init__.py

@@ -0,0 +1,108 @@
+"""RunPod Flash provider: managed, serverless GPUs (no Docker) for AutoSLM.
+
+Fine-tuning runs on a dedicated RunPod GPU provisioned by Flash. A decorated Python
+handler (``train._train_body``) executes ``autoslm.engine.worker`` on the GPU; Flash
+handles provisioning, dependency install, execution, and scale-to-zero teardown.
+Serving exposes an OpenAI-compatible endpoint for a trained LoRA adapter.
+
+``PROVIDER`` is the ``base.Provider`` implementation the registry hands out; the
+orchestrator/allocator only talk to its interface, never these modules directly.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from autoslm.providers.base import GpuClass, JobHandle, PollResult, Provider
+
+
+class RunpodProvider:
+    """``base.Provider`` for the RunPod Flash substrate."""
+
+    name = "runpod"
+
+    def is_configured(self) -> bool:
+        # RunPod is the ALWAYS-ON default substrate, so it is always "available" for
+        # allocation (offline pricing degrades to the static snapshot, and a missing
+        # RUNPOD_API_KEY surfaces at provision time via ensure_auth / the preflight —
+        # never as a silent empty candidate list). This matches the historical
+        # ``available_providers()`` which listed runpod unconditionally.
+        return True
+
+    def preflight(self, require_hf: bool = True) -> list[str]:
+        from autoslm.providers.runpod.preflight import missing_credentials
+
+        return missing_credentials(require_hf=require_hf)
+
+    def gpu_classes(self) -> list[GpuClass]:
+        from autoslm.providers.runpod.gpus import gpu_classes
+
+        return gpu_classes()
+
+    def hourly_rate(self, gpu: str) -> float:
+        from autoslm.providers.runpod.pricing import hourly_rate
+
+        return hourly_rate(gpu)
+
+    def submit_run(
+        self,
+        spec,
+        seed: int,
+        *,
+        log: Any = None,
+        on_handle: Any = None,
+        attempt: int = 0,
+        offers: Any = None,
+        exclude_machine_ids: Any = frozenset(),
+    ) -> PollResult:
+        # ``offers``/``exclude_machine_ids`` are Vast live-market concerns; RunPod
+        # provisions a fresh serverless endpoint and never re-searches a market, so it
+        # ignores both (kept in the signature for cross-provider symmetry).
+        from autoslm.providers.runpod.jobs import submit_run
+
+        return submit_run(spec, seed, log=log, on_handle=on_handle, attempt=attempt)
+
+    def poll(self, handle: JobHandle, spec, seed: int, *, log: Any = None) -> PollResult:
+        from autoslm.providers.runpod.jobs import JobHandle as RunpodJobHandle
+        from autoslm.providers.runpod.jobs import (
+            make_hf_heartbeat_reader,
+            poll_job,
+            stall_kwargs,
+        )
+
+        hf_repo = spec.train.hf_repo
+        prefix = f"{spec.phase}/{spec.run_id}/seed{seed}"
+        reader = make_hf_heartbeat_reader(hf_repo, prefix) if hf_repo else None
+        rh = RunpodJobHandle.from_dict(handle.to_dict())
+        if log is not None:
+            print(f"attaching: job={rh.job_id} endpoint={rh.endpoint_name}", file=log, flush=True)
+        # Same stall tuning as the submit path so a reattached run isn't judged differently.
+        return poll_job(rh, log=log, heartbeat_reader=reader, **stall_kwargs())
+
+    def cancel(self, handle: JobHandle) -> None:
+        from autoslm.providers.runpod import api as runpod_api
+
+        d = handle.to_dict()
+        if d.get("endpoint_id") and d.get("job_id"):
+            runpod_api.cancel_job(d["endpoint_id"], d["job_id"])
+
+    def destroy(self, handle: JobHandle) -> None:
+        from autoslm.providers.runpod import api as runpod_api
+
+        d = handle.to_dict()
+        if d.get("endpoint_id"):
+            runpod_api.delete_endpoint(d["endpoint_id"])
+
+    def gc(self, spec) -> None:
+        from autoslm.providers.runpod.train import terminate_endpoint
+
+        terminate_endpoint(spec.gpu.type, spec.run_id)
+
+    def sweep_orphans(self, active_labels: set[str] | None = None) -> list[int]:
+        # No-op: RunPod serverless endpoints have no standing per-run billing to reap on
+        # crash recovery (a failed-before-submit endpoint is GC'd by reconstructed name in
+        # recover_runs). Present for ``base.Provider`` symmetry with Vast's instance sweep.
+        return []
+
+
+PROVIDER: Provider = RunpodProvider()

code/autoslm/providers/runpod/api.py

@@ -0,0 +1,117 @@
+"""Thin RunPod REST client (no SDK state): endpoints, queue jobs, health.
+
+Used by the run supervisor and endpoint GC so that a *fresh process* can
+reattach to / clean up after any run using only the persisted ids + RUNPOD_API_KEY —
+independent of the Flash SDK's local resource registry (which is per-directory,
+whole-dict, last-writer-wins and therefore unreliable across processes).
+"""
+
+from __future__ import annotations
+
+import urllib.error
+from typing import Any
+
+from autoslm.providers._http import RestClient
+
+REST_BASE = "https://rest.runpod.io/v1"
+QUEUE_BASE = "https://api.runpod.ai/v2"
+
+
+class RunpodApiError(RuntimeError):
+    pass
+
+
+# Shared urllib client (full-URL form: callers pass absolute REST/QUEUE urls).
+# Env-only by design: ~/.autoslm/config.json holds the *AutoSLM* key (client-side),
+# never the RunPod key — the operator sets RUNPOD_API_KEY on the control-plane host.
+_CLIENT = RestClient(env_var="RUNPOD_API_KEY", error_cls=RunpodApiError)
+
+
+def _api_key() -> str:
+    return _CLIENT.api_key()
+
+
+def _request(url: str, method: str = "GET", body: dict | None = None, timeout: float = 30.0):
+    return _CLIENT.request(url, method=method, body=body, timeout=timeout)
+
+
+def request_with_retries(
+    url: str,
+    method: str = "GET",
+    body: dict | None = None,
+    retries: int = 4,
+    base_delay: float = 2.0,
+) -> Any:
+    """REST call hardened against transient network/5xx blips (jittered backoff)."""
+    return _CLIENT.request_with_retries(
+        url, method=method, body=body, retries=retries, base_delay=base_delay
+    )
+
+
+# ---------------------------------------------------------------------------
+# Endpoints
+# ---------------------------------------------------------------------------
+def list_endpoints() -> list[dict]:
+    out = request_with_retries(f"{REST_BASE}/endpoints")
+    return out if isinstance(out, list) else []
+
+
+def find_endpoints_by_name(substr: str) -> list[dict]:
+    return [e for e in list_endpoints() if substr in (e.get("name") or "")]
+
+
+def delete_endpoint(endpoint_id: str) -> bool:
+    try:
+        request_with_retries(f"{REST_BASE}/endpoints/{endpoint_id}", method="DELETE", retries=2)
+        return True
+    except RunpodApiError as e:
+        # An already-gone endpoint is a clean teardown, not a failure: a 404 (or a body
+        # saying the endpoint "does not exist") means the desired end state — no such
+        # endpoint — already holds. Reporting False here makes undeploy_adapter surface a
+        # misleading "may still be running" 502 for something that's provably gone.
+        return _is_not_found(e)
+
+
+def _is_not_found(err: RunpodApiError) -> bool:
+    """True only when a RunpodApiError represents a genuine 404 (endpoint already gone).
+
+    request_with_retries chains the original urllib HTTPError as ``__cause__`` for every
+    fast-failed 4xx (``raise ... from e``), so the status code is authoritative when a
+    cause is present: a 404 is "already gone", anything else (403/401/5xx) is a real
+    failure and must NOT be swallowed — a body that merely *mentions* "does not exist" on a
+    403 is still a 403. We only fall back to a text match when there is no HTTPError cause
+    (e.g. the "failed after N attempts" path), and even then only on an unambiguous 404.
+    """
+    cause = err.__cause__
+    if isinstance(cause, urllib.error.HTTPError):
+        return cause.code == 404
+    return "http 404" in str(err).lower()
+
+
+def endpoint_health(endpoint_id: str) -> dict:
+    return request_with_retries(f"{QUEUE_BASE}/{endpoint_id}/health")
+
+
+# ---------------------------------------------------------------------------
+# Queue jobs
+# ---------------------------------------------------------------------------
+def submit_job(endpoint_id: str, input_payload: dict) -> str:
+    """POST /run -> job id (async queue submission)."""
+    out = request_with_retries(
+        f"{QUEUE_BASE}/{endpoint_id}/run", method="POST", body={"input": input_payload}
+    )
+    job_id = out.get("id")
+    if not job_id:
+        raise RunpodApiError(f"submit_job: no job id in response: {out}")
+    return job_id
+
+
+def job_status(endpoint_id: str, job_id: str) -> dict:
+    """GET /status/<job_id> -> {status, output?, error?, ...}."""
+    return request_with_retries(f"{QUEUE_BASE}/{endpoint_id}/status/{job_id}")
+
+
+def cancel_job(endpoint_id: str, job_id: str) -> dict:
+    return request_with_retries(
+        f"{QUEUE_BASE}/{endpoint_id}/cancel/{job_id}", method="POST", retries=2
+    )

code/autoslm/providers/runpod/auth.py

@@ -0,0 +1,25 @@
+"""RunPod credential handling for the managed Flash backend (operator-side).
+
+The Flash SDK authenticates via the ``RUNPOD_API_KEY`` environment variable, set by
+the **operator** on the control-plane host. End users never
+provide provider credentials — they authenticate to the control plane with an AutoSLM
+key. Deliberately env-only: ``~/.autoslm/config.json`` holds the *AutoSLM* key, which
+must never be mistaken for a RunPod key.
+"""
+
+from __future__ import annotations
+
+import os
+
+
+def load_api_key() -> str | None:
+    """RunPod API key from the environment (operator configuration)."""
+    return os.environ.get("RUNPOD_API_KEY") or None
+
+
+def ensure_auth() -> str:
+    """Ensure ``RUNPOD_API_KEY`` is set for the Flash SDK; raise if unavailable."""
+    key = load_api_key()
+    if not key:
+        raise RuntimeError("no RunPod API key found; set RUNPOD_API_KEY on the control-plane host")
+    return key

code/autoslm/providers/runpod/gpus.py

@@ -0,0 +1,46 @@
+"""RunPod's GPU classes + the Flash-specific bits of the shared GPU table.
+
+The class table itself is provider-agnostic and lives in ``providers/base.py`` (one
+canonical row per friendly name). This module carves out RunPod's rows
+(``gpu_classes()`` == every class with a Flash ``enum_member``) and owns the
+RunPod-only translation: friendly name -> Flash ``GpuType``.
+"""
+
+from __future__ import annotations
+
+from autoslm.providers.base import (
+    GpuClass,
+    UnsupportedGpuError,
+    get_gpu_info,
+    providers_for,
+)
+
+
+# Lazy import so unit tests that only exercise the mapping don't pull the whole SDK
+# graph unless needed. ``runpod_flash`` is a hard dependency, so this import is safe.
+def _gpu_enum():
+    from runpod_flash import GpuType
+
+    return GpuType
+
+
+def gpu_classes() -> list[GpuClass]:
+    """The GPU classes RunPod Flash can provision (those with a ``GpuType`` member)."""
+    from autoslm.providers.base import GPU_INFO
+
+    return [g for g in GPU_INFO.values() if g.enum_member]
+
+
+def flash_gpu(name: str):
+    """Return the RunPod Flash ``GpuType`` for a friendly GPU name."""
+    info = get_gpu_info(name)
+    if not info.enum_member:
+        raise UnsupportedGpuError(
+            f"{info.name} is not available on RunPod (providers: {', '.join(providers_for(name))})"
+        )
+    return getattr(_gpu_enum(), info.enum_member)
+
+
+def gpu_api_id(name: str) -> str:
+    """RunPod API GPU id (the ``GpuType`` enum value, e.g. 'NVIDIA GeForce RTX 4090')."""
+    return flash_gpu(name).value

code/autoslm/providers/runpod/jobs.py

@@ -0,0 +1,494 @@
+"""Durable run primitives: explicit deploy -> submit -> poll with a persisted job handle.
+
+Calling `runpod_flash`'s all-in-one blocking handler directly would tie a run's life to
+one client process and one HTTP poll loop: a client crash/network blip orphans an
+otherwise-healthy GPU job (no job id is ever persisted), and any SDK polling bug kills
+the run. This module owns the lifecycle instead:
+
+  deploy_train_endpoint()  -> endpoint_id (Flash SDK deploy, same worker template)
+  build_function_input()   -> the exact FunctionRequest payload Flash workers expect
+  submit + poll_job()      -> REST queue API with hardened retries; the job handle
+                              {endpoint_id, job_id} is persisted by the runner so
+                              any process can re-attach (`slm attach`).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import contextlib
+import json
+import os
+import time
+from dataclasses import dataclass
+
+from autoslm._logging import get_logger
+from autoslm.providers._poll import PollErrorTracker, make_say, surface_heartbeat
+from autoslm.providers.base import PollResult, canonical_gpu
+from autoslm.providers.runpod import api as runpod_api
+from autoslm.providers.runpod.gpus import flash_gpu
+from autoslm.providers.runpod.train import (
+    DEFAULT_EXECUTION_TIMEOUT_MS,
+    FLASH_SDK_LOCK,
+    WORKER_IMAGE,
+    WORKER_SYSTEM_DEPS,
+    _patch_runpod_backoff,
+    _train_body,
+    endpoint_name,
+    isolate_flash_state,
+    min_cuda_for,
+    resolve_worker_deps,
+)
+
+logger = get_logger(__name__)
+
+# Re-export so callers/tests that did ``from ...jobs import PollResult`` keep working.
+__all__ = [
+    "JobHandle",
+    "PollResult",
+    "apply_disk_gb",
+    "build_function_input",
+    "decode_output",
+    "deploy_train_endpoint",
+    "make_hf_heartbeat_reader",
+    "make_hf_text_reader",
+    "poll_job",
+    "submit_run",
+    "volume_endpoint_kwargs",
+]
+
+TERMINAL_OK = {"COMPLETED"}
+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", "rl_server_boot"}
+)
+
+
+def stall_kwargs() -> dict:
+    """``poll_job`` stall-window kwargs, shared by the submit and reattach paths so a recovered
+    run uses the same tuning as the original submit. ``stall_after_s`` = post-training-heartbeat
+    window; ``setup_grace_s`` = the larger cold-start window before the first training heartbeat;
+    ``queue_grace_s`` = how long a job may sit IN_QUEUE (no worker assigned) before it's judged
+    capacity-starved and fails ``no_capacity`` so the orchestrator advances to the next class.
+    """
+    return {"stall_after_s": 1500.0, "setup_grace_s": 3000.0, "queue_grace_s": 720.0}
+
+
+def volume_endpoint_kwargs(spec) -> dict:
+    """Endpoint kwargs for the OPT-IN persistent network volume (cross-run HF cache).
+
+    Returns {} unless ``gpu.network_volume`` is set. The volume pins the endpoint to
+    one datacenter (``gpu.datacenter``, default EU-RO-1 — the SDK's storage default),
+    which shrinks the available GPU pool; that trade-off is why this is opt-in.
+    """
+    nv = getattr(spec.gpu, "network_volume", None) if spec is not None else None
+    if not nv:
+        return {}
+    from runpod_flash import NetworkVolume
+    from runpod_flash.core.resources.datacenter import DataCenter
+
+    dc = DataCenter.from_string(spec.gpu.datacenter) if spec.gpu.datacenter else None
+    volume = NetworkVolume(
+        name=str(nv),
+        size=int(getattr(spec.gpu, "network_volume_gb", 100) or 100),
+        **({"datacenter": dc} if dc else {}),
+    )
+    kwargs: dict = {"volume": volume}
+    if dc:
+        kwargs["datacenter"] = dc
+    return kwargs
+
+
+def apply_disk_gb(config, disk_gb: int | None) -> None:
+    """Raise the worker's container disk on a built endpoint config.
+
+    The Flash SDK's ``PodTemplate.containerDiskInGb`` defaults to 64 GB and the
+    ``Endpoint`` wrapper exposes no disk knob, which is what blocked models whose
+    checkpoint alone exceeds 64 GB. The template
+    is already populated by the SDK's validators when the resource config is built, so
+    raising the field here is the supported injection point. Raise-only: shrinking
+    below the SDK default buys nothing (serverless disk isn't billed separately) and
+    would regress runs whose configs carry the historical ``disk_gb = 60`` default.
+    """
+    if not disk_gb:
+        return
+    template = getattr(config, "template", None)
+    if template is None:
+        logger.warning("disk_gb=%s requested but endpoint config has no template", disk_gb)
+        return
+    template.containerDiskInGb = max(int(disk_gb), int(template.containerDiskInGb or 0))
+
+
+@dataclass
+class JobHandle:
+    endpoint_id: str
+    endpoint_name: str
+    job_id: str
+
+    def to_dict(self) -> dict:
+        return {
+            "provider": "runpod",
+            "endpoint_id": self.endpoint_id,
+            "endpoint_name": self.endpoint_name,
+            "job_id": self.job_id,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> JobHandle:
+        # `provider` is routing metadata consumed upstream (runner); handles
+        # persisted before it existed default to runpod there.
+        return cls(d["endpoint_id"], d.get("endpoint_name", ""), d["job_id"])
+
+
+def deploy_train_endpoint(
+    friendly_gpu: str,
+    execution_timeout_ms: int | None = None,
+    name_suffix: str | None = None,
+    disk_gb: int | None = None,
+    spec=None,
+) -> tuple[str, str]:
+    """Deploy (or reuse) the run's uniquely-named worker endpoint; return (id, name)."""
+    os.environ["FLASH_IS_LIVE_PROVISIONING"] = "true"
+    from runpod_flash import Endpoint
+
+    from autoslm.providers.runpod.auth import ensure_auth
+
+    ensure_auth()
+    _patch_runpod_backoff()
+    friendly = canonical_gpu(friendly_gpu)
+    name = endpoint_name(friendly, name_suffix)
+    image = WORKER_IMAGE
+    from runpod_flash.core.resources.resource_manager import ResourceManager
+
+    # isolate_flash_state mutates runpod_flash's process-wide registry globals for this run's
+    # suffix, and ResourceManager + the deploy share the SDK's asyncio singleton. Hold the
+    # lock across the whole critical section so a concurrent run can't swap the registry
+    # scope or race the event loop mid-deploy.
+    with FLASH_SDK_LOCK:
+        isolate_flash_state(name_suffix)
+        kwargs = dict(
+            name=name,
+            gpu=flash_gpu(friendly),
+            # GPUs per worker on the endpoint (= trainer + inference_gpus). >1 for the
+            # disaggregated async GRPO path; default 1 (single-GPU colocate).
+            gpu_count=max(1, int(getattr(getattr(spec, "gpu", None), "count", 1))),
+            min_cuda_version=min_cuda_for(friendly),
+            execution_timeout_ms=execution_timeout_ms or DEFAULT_EXECUTION_TIMEOUT_MS,
+            workers=(0, 1),
+            **volume_endpoint_kwargs(spec),
+        )
+        if image:
+            kwargs["image"] = image
+        else:
+            # Pass the resolved GPU so Hopper (sm90) gets its fla-drop treatment (resolve_worker_deps
+            # is GPU-scoped); a bare call would ship the generic deps and run fla's #640-buggy GDN
+            # Triton kernel on an H100 instead of the correct pure-PyTorch delta rule.
+            kwargs["dependencies"] = resolve_worker_deps(friendly)
+            kwargs["system_dependencies"] = WORKER_SYSTEM_DEPS
+        ep = Endpoint(**kwargs)
+        ep._qb_target = _train_body
+        config = ep._build_resource_config()
+        apply_disk_gb(config, disk_gb)
+        # Worker image is PUBLIC, so no container-registry credential is needed to pull it.
+        rm = ResourceManager()
+        resource = asyncio.run(rm.get_or_deploy_resource(config))
+    endpoint_id = getattr(resource, "id", None)
+    if not endpoint_id:
+        raise RuntimeError(f"deploy_train_endpoint: no endpoint id on resource {resource!r}")
+    return endpoint_id, name
+
+
+def build_function_input(payload: dict, friendly_gpu: str | None = None) -> dict:
+    """The FunctionRequest dict a Flash queue worker expects for `_train_body(payload)`.
+
+    ``friendly_gpu`` is threaded into ``resolve_worker_deps`` so the request-level dependency
+    list is GPU-scoped exactly like the endpoint config (deploy_train_endpoint): on Hopper (sm90)
+    it must drop ``flash-linear-attention`` so the worker uses the pure-PyTorch delta rule instead
+    of fla's #640-buggy GDN Triton kernel. A bare call would reinstall the generic deps and
+    reintroduce that sm90 correctness issue even when the endpoint was configured correctly.
+    """
+    from runpod_flash.runtime.serialization import serialize_args
+    from runpod_flash.stubs.live_serverless import get_function_source
+
+    source, _src_hash = get_function_source(_train_body)
+    req: dict = {
+        "function_name": "_train_body",
+        "function_code": source,
+        "args": serialize_args((payload,)),
+        "accelerate_downloads": True,
+    }
+    if not WORKER_IMAGE:
+        req["dependencies"] = resolve_worker_deps(canonical_gpu(friendly_gpu) if friendly_gpu else None)
+        req["system_dependencies"] = WORKER_SYSTEM_DEPS
+    return req
+
+
+def decode_output(output) -> dict:
+    """Decode a Flash FunctionResponse job output into the worker's metrics dict."""
+    if isinstance(output, str):
+        try:
+            output = json.loads(output)
+        except json.JSONDecodeError as exc:
+            raise RuntimeError(f"unexpected job output: {output[:200]}") from exc
+    if not isinstance(output, dict):
+        raise RuntimeError(f"unexpected job output type: {type(output)}")
+    if output.get("success") and output.get("result") is not None:
+        import cloudpickle
+
+        result = cloudpickle.loads(base64.b64decode(output["result"]))
+        if not isinstance(result, dict):
+            raise RuntimeError(f"flash job returned no metrics: {result!r}")
+        return result
+    err = output.get("error") or "unknown worker error"
+    stdout_tail = (output.get("stdout") or "")[-1500:]
+    raise RuntimeError(f"Remote execution failed: {err}\n--- worker stdout tail ---\n{stdout_tail}")
+
+
+def poll_job(
+    handle: JobHandle,
+    log=None,
+    interval_s: float = 10.0,
+    heartbeat_reader=None,
+    stall_after_s: float = 1200.0,
+    setup_grace_s: float = 3000.0,
+    queue_grace_s: float = 720.0,
+    deadline_s: float | None = None,
+) -> PollResult:
+    """Poll a queue job to completion; resilient to transient API errors.
+
+    Two stall windows: the cold-start phase (dep install, per-run env pip, model download,
+    vLLM init) is slow and only emits *setup* heartbeats (``_SETUP_HEARTBEAT_STAGES``).
+    Until a *training* heartbeat arrives we apply the larger ``setup_grace_s`` budget so a
+    slow cold start isn't misread as a stall; after it we use the tight ``stall_after_s``.
+    Needs a ``heartbeat_reader`` to tell the phases apart — without one we keep
+    ``stall_after_s`` throughout (no regression).
+    """
+
+    say = make_say(log)
+    poll_errors = PollErrorTracker(say, interval_s)
+
+    start = time.time()
+    last_status = None
+    last_hb_key = None
+    last_progress = time.time()
+    seen_heartbeat = False
+    last_health_probe = 0.0
+    while True:
+        if deadline_s is not None and time.time() - start > deadline_s:
+            return PollResult(False, failure="stalled", detail="client-side deadline exceeded")
+        try:
+            st = runpod_api.job_status(handle.endpoint_id, handle.job_id)
+            poll_errors.reset()
+        except runpod_api.RunpodApiError as e:
+            if poll_errors.record(e):
+                return PollResult(False, failure="poll_error", detail=str(e))
+            continue
+        status = st.get("status")
+        if status != last_status:
+            say(f"job {handle.job_id}: {status}")
+            last_status = status
+            last_progress = time.time()
+        if status in TERMINAL_OK:
+            try:
+                return PollResult(True, metrics=decode_output(st.get("output")))
+            except RuntimeError as e:
+                return PollResult(False, failure="job_failed", detail=str(e))
+        if status in TERMINAL_FAIL:
+            detail = str(st.get("error") or "")[:1500]
+            out = st.get("output")
+            if isinstance(out, dict) and out.get("stdout"):
+                # Worker stdout tail is the only place the REAL root cause lives for
+                # crashes inside subprocesses (e.g. vLLM EngineCore deaths).
+                detail += "\n--- worker stdout tail ---\n" + str(out["stdout"])[-2000:]
+            elif not detail:
+                detail = str(out)[:1500]
+            # Prefix the terminal status so the runner's infra-retry markers
+            # (e.g. TIMED_OUT) match even when RunPod sets no error/output text.
+            return PollResult(False, failure="job_failed", detail=f"[{status}] {detail}")
+        # While queued, surface worker availability (throttled hosts are the common
+        # cause of silent multi-minute waits — make them visible in the run log).
+        if status == "IN_QUEUE" and time.time() - last_health_probe > 90:
+            last_health_probe = time.time()
+            try:
+                h = runpod_api.endpoint_health(handle.endpoint_id)
+                workers = h.get("workers") or {}
+                if any(workers.get(k) for k in ("throttled", "unhealthy", "initializing")) or not (
+                    workers.get("running") or workers.get("ready") or workers.get("idle")
+                ):
+                    say(f"queued; workers: {workers}")
+            except Exception:
+                # Health surfacing is diagnostic only; a probe failure must not stop polling.
+                pass
+        # CAPACITY FAST-PATH: a job that can't even LEAVE the queue (no worker ever assigned)
+        # is on a capacity-starved GPU class — RunPod keeps the worker `throttled` and the job
+        # IN_QUEUE indefinitely. Fail FAST with ``no_capacity`` (well before the multi-minute
+        # setup grace) so the orchestrator advances to the next-cheapest AVAILABLE class instead
+        # of burning the whole retry budget on a class with zero free workers. Only fires while
+        # still IN_QUEUE: once a worker picks the job up (status RUNNING) the slow-but-legit
+        # cold start (image pull / dep install / model download) gets the full setup grace below.
+        if status == "IN_QUEUE" and time.time() - last_progress > queue_grace_s:
+            return PollResult(
+                False,
+                failure="no_capacity",
+                detail=(
+                    f"no worker assigned for {int(time.time() - last_progress)}s while IN_QUEUE "
+                    f"(GPU class capacity-starved / throttled; limit {int(queue_grace_s)}s) — "
+                    "advancing to the next-cheapest available class"
+                ),
+            )
+        # heartbeat progress surfacing + stall detection
+        new_key, stage = surface_heartbeat(heartbeat_reader, last_hb_key, say)
+        if new_key != last_hb_key:
+            last_hb_key = new_key
+            last_progress = time.time()
+            # Only a training-phase heartbeat means cold-start setup is done and we
+            # can switch to the tight window; setup heartbeats keep the grace budget.
+            if stage not in _SETUP_HEARTBEAT_STAGES:
+                seen_heartbeat = True
+        # Cold start (before any training-phase heartbeat) gets the larger setup_grace_s,
+        # but only when a heartbeat_reader lets us tell setup from training; without one we
+        # can't, so stay on stall_after_s (no regression).
+        in_setup = heartbeat_reader is not None and not seen_heartbeat
+        stall_limit = setup_grace_s if in_setup else stall_after_s
+        if time.time() - last_progress > stall_limit:
+            phase = "setup (pre-training)" if in_setup else "training"
+            return PollResult(
+                False,
+                failure="stalled",
+                detail=f"no worker progress for {int(time.time() - last_progress)}s "
+                f"during {phase} (job status {status}, limit {int(stall_limit)}s)",
+            )
+        time.sleep(interval_s)
+
+
+def submit_run(spec, seed: int, log=None, on_handle=None, attempt: int = 0) -> PollResult:
+    """Durable equivalent of ``submit_train``: deploy, submit, persist handle, poll.
+
+    ``on_handle(handle_dict)`` is invoked as soon as the job is queued so the
+    runner can persist {endpoint_id, job_id} for cross-process reattach.
+    """
+    from autoslm.envs.registry import worker_hub_env_ids, worker_pip_for_env
+    from autoslm.providers.runpod.train import _run_suffix, build_worker_env
+
+    timeout_s = max(60, int(spec.gpu.max_wall_seconds))
+    # Per-attempt endpoint name: a retry must land on a genuinely fresh endpoint —
+    # reusing the name lets the SDK/platform pin the job back onto the same
+    # (possibly throttled/sick) host.
+    suffix = _run_suffix(spec.run_id)
+    if attempt:
+        suffix = f"{suffix}r{attempt}"
+    # Resolve the worker env BEFORE provisioning: an unrecorded Hub env raises here, and
+    # doing it after deploy_train_endpoint() would leak the just-created endpoint (its
+    # rN-suffixed name can't be reconstructed from the run id later) against the account
+    # quota — the runner would also treat the raise as a retryable poll_error.
+    extra_pip = list(spec.environment.pip) or worker_pip_for_env(spec.environment.id)
+    worker_env = build_worker_env(spec, seed)
+    endpoint_id, name = deploy_train_endpoint(
+        spec.gpu.type,
+        execution_timeout_ms=timeout_s * 1000,
+        name_suffix=suffix,
+        disk_gb=spec.gpu.disk_gb,
+        spec=spec,
+    )
+    payload = {
+        "hf_repo": spec.train.hf_repo,
+        "job_spec_json": spec.to_json(),
+        "phase": spec.phase,
+        "seed": int(seed),
+        "env": worker_env,
+        "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, 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
+        # id later — delete it now so a transient submit failure doesn't leak a
+        # serverless endpoint against the account quota.
+        with contextlib.suppress(Exception):
+            runpod_api.delete_endpoint(endpoint_id)
+        raise
+    handle = JobHandle(endpoint_id, name, job_id)
+    if log is not None:
+        print(
+            f"submitted job: endpoint={name} ({endpoint_id}) job={job_id} "
+            f"attempt={attempt} gpu={spec.gpu.type} phase={spec.phase} seed={seed}",
+            file=log,
+            flush=True,
+        )
+    if on_handle is not None:
+        on_handle(handle.to_dict())
+    hf_repo = spec.train.hf_repo
+    prefix = f"{spec.phase}/{spec.run_id}/seed{seed}"
+    reader = make_hf_heartbeat_reader(hf_repo, prefix) if hf_repo else None
+    return poll_job(handle, log=log, heartbeat_reader=reader, **stall_kwargs())
+
+
+def make_hf_text_reader(hf_repo: str, path_in_repo: str, min_interval_s: float = 45.0):
+    """Rate-limited reader for one HF artifact's text content (None until it exists).
+
+    Generic helper shared by both providers' pollers (runpod heartbeats + vast's
+    DONE/metrics/error artifacts). ``read(force=False)`` re-downloads at most once per
+    ``min_interval_s`` (``force=True`` bypasses the gate); it never raises — any HF error
+    (artifact absent, network) returns None.
+    """
+    state = {"last": 0.0}
+
+    def read(force: bool = False) -> str | None:
+        if not hf_repo:
+            return None
+        if not force and time.time() - state["last"] < min_interval_s:
+            return None
+        state["last"] = time.time()
+        try:
+            from huggingface_hub import hf_hub_download
+
+            p = hf_hub_download(
+                hf_repo,
+                path_in_repo,
+                repo_type="dataset",
+                token=os.environ.get("HF_TOKEN"),
+                force_download=True,
+            )
+            with open(p) as f:
+                return f.read()
+        except Exception:
+            return None
+
+    return read
+
+
+def make_hf_heartbeat_reader(hf_repo: str, prefix: str, min_interval_s: float = 30.0):
+    """Reader for the worker's heartbeat.json on HF (rate-limited, never raises).
+
+    Thin JSON-parsing wrapper over :func:`make_hf_text_reader` bound to ``{prefix}/heartbeat.json``.
+    """
+    text_reader = make_hf_text_reader(hf_repo, f"{prefix}/heartbeat.json", min_interval_s)
+
+    def read() -> dict | None:
+        raw = text_reader()
+        if raw is None:
+            return None
+        try:
+            return json.loads(raw)
+        except (ValueError, TypeError):
+            return None
+
+    return read

code/autoslm/providers/runpod/preflight.py

@@ -0,0 +1,30 @@
+"""Fail-fast credential checks for the RunPod substrate (operator-side).
+
+These run when the AutoSLM server starts (and before any RunPod Flash provisioning) so
+missing operator configuration produces one clear, actionable error instead of a
+partial run that dies mid-provisioning. End users never see these — their preflight is
+client-side ("do I have an AutoSLM key?", see autoslm/client).
+"""
+
+from __future__ import annotations
+
+import os
+
+from autoslm.providers.runpod.auth import load_api_key
+
+
+class PreflightError(RuntimeError):
+    """Raised when required operator credentials/configuration are missing."""
+
+
+def missing_credentials(require_hf: bool = True) -> list[str]:
+    """RunPod-related operator config that is missing (empty list == ready)."""
+    problems: list[str] = []
+    if not load_api_key():
+        problems.append("  - RUNPOD_API_KEY: the operator's RunPod API key")
+    if require_hf and not os.environ.get("HF_TOKEN"):
+        problems.append(
+            "  - HF_TOKEN: a token with write access to each run's "
+            "`[train] hf_repo`, e.g. `export HF_TOKEN=hf_...`"
+        )
+    return problems

code/autoslm/providers/runpod/pricing.py

@@ -0,0 +1,110 @@
+"""Per-GPU hourly rates: RunPod live pricing with a static fallback.
+
+Cost projection (runner, serve) and the ``gpu.type = "cheapest"`` policy both
+need $/hr per GPU class. Rates move with the market, so we read them live from the
+RunPod pricing API (the ``runpod`` SDK's GraphQL wrapper — the plain REST surface has
+no GPU-types route and direct GraphQL is 403 for scoped keys) and cache them on disk;
+any failure falls back to the static snapshot in ``providers.base.GPU_INFO``.
+
+Rates are RunPod secure-cloud on-demand — representative for ranking and projection,
+not an exact serverless invoice (the worker also records wall time; real cost comes
+from RunPod billing).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+
+from autoslm._logging import get_logger
+
+logger = get_logger(__name__)
+
+CACHE_TTL_S = float(os.environ.get("AUTOSLM_PRICE_TTL_S", str(6 * 3600)))
+_CACHE_PATH = Path.home() / ".autoslm" / "gpu_rates.json"
+_MEM: dict = {"ts": 0.0, "rates": {}}
+
+
+def _static_rates() -> dict[str, float]:
+    from autoslm.providers.base import GPU_INFO
+
+    return {name: info.hourly_usd for name, info in GPU_INFO.items()}
+
+
+def _pick_rate(detail: dict) -> float | None:
+    """Best representative on-demand rate from a RunPod gpuTypes detail row."""
+    for key in ("securePrice", "communityPrice"):
+        v = detail.get(key)
+        if v:
+            return float(v)
+    v = (detail.get("lowestPrice") or {}).get("uninterruptablePrice")
+    return float(v) if v else None
+
+
+def _fetch_live_rates() -> dict[str, float]:
+    """One pricing call per managed GPU class (the list query carries no prices)."""
+    import runpod
+
+    from autoslm.providers.base import GPU_INFO
+    from autoslm.providers.runpod.gpus import gpu_api_id
+
+    if not runpod.api_key:
+        runpod.api_key = os.environ.get("RUNPOD_API_KEY")
+    rates: dict[str, float] = {}
+    for name, info in GPU_INFO.items():
+        if not info.enum_member:  # Vast-only class -> no RunPod pricing route
+            continue
+        try:
+            rate = _pick_rate(runpod.get_gpu(gpu_api_id(name)) or {})
+        except Exception as exc:
+            logger.debug("live rate fetch failed for %s: %s", name, exc)
+            continue
+        if rate:
+            rates[name] = rate
+    return rates
+
+
+def live_rates(refresh: bool = False) -> dict[str, float]:
+    """Friendly-name -> $/hr. Live (cached ``CACHE_TTL_S``) over the static snapshot.
+
+    Offline-safe: AUTOSLM_SKIP_NET (or any fetch failure) returns the static rates.
+    """
+    static = _static_rates()
+    if os.environ.get("AUTOSLM_SKIP_NET"):
+        return static
+    now = time.time()
+    if not refresh:
+        if _MEM["rates"] and now - _MEM["ts"] < CACHE_TTL_S:
+            return {**static, **_MEM["rates"]}
+        try:
+            disk = json.loads(_CACHE_PATH.read_text())
+            if now - float(disk.get("ts", 0)) < CACHE_TTL_S and disk.get("rates"):
+                _MEM.update(ts=float(disk["ts"]), rates=dict(disk["rates"]))
+                return {**static, **_MEM["rates"]}
+        except Exception:
+            # Corrupt/unreadable cache: ignore and fall through to a live fetch.
+            pass
+    try:
+        fetched = _fetch_live_rates()
+    except Exception as exc:
+        logger.warning("live GPU pricing unavailable (%s); using static rates", exc)
+        fetched = {}
+    if fetched:
+        _MEM.update(ts=now, rates=fetched)
+        try:
+            _CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+            _CACHE_PATH.write_text(json.dumps({"ts": now, "rates": fetched}))
+        except Exception:
+            # Cache write is an optimization; a read-only/full FS shouldn't fail pricing.
+            pass
+    return {**static, **_MEM["rates"]}
+
+
+def hourly_rate(gpu_name: str) -> float:
+    """$/hr for one friendly GPU name (live if available, else static)."""
+    from autoslm.providers.base import canonical_gpu
+
+    name = canonical_gpu(gpu_name)
+    return live_rates().get(name) or _static_rates()[name]

code/autoslm/providers/runpod/train.py

@@ -0,0 +1,823 @@
+"""RunPod Flash fine-tuning endpoints (queue-based, one dedicated GPU per run).
+
+Flash provisions a dedicated RunPod GPU (RTX 4090 / 5090, no Docker), installs
+``WORKER_DEPS``, runs the handler, returns the metrics dict, and scales to zero.
+
+Flash's live ("ad-hoc") provisioning does not bundle local project code, so the
+handler fetches the ``autoslm`` package from the HF dataset repo (uploaded by
+``upload_code`` before submit), adds it to ``PYTHONPATH``, and runs
+``autoslm.engine.worker`` to train. The worker streams the adapter + checkpoints to
+the same HF repo for serving and preemption-resilient resume.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import inspect
+import os
+import threading
+from typing import Any
+
+from autoslm._logging import get_logger
+from autoslm.providers.base import canonical_gpu, gpu_short
+from autoslm.providers.runpod.gpus import flash_gpu
+from autoslm.spec import JobSpec
+
+logger = get_logger(__name__)
+
+# The control plane runs each training run in its own thread. All runpod_flash deploy/
+# undeploy work goes through a shared asyncio singleton whose Lock binds to the first event
+# loop that touches it; two threads each calling asyncio.run() get distinct loops and the
+# second fails with "Lock ... is bound to a different event loop". Serialize every Flash SDK
+# async section (deploy AND undeploy) behind this one process-wide lock. Deploys/teardowns
+# are infrequent vs training, so the serialization cost is negligible.
+FLASH_SDK_LOCK = threading.Lock()
+
+
+# Worker stack: trl 1.6 (colocate default; adds the GRPO `tools=` / `rollout_func`
+# multi-turn hooks used for verifiers ToolEnv / MultiTurnEnv training), vllm 0.19.1
+# (Qwen3.5/3.6 archs, native RL APIs, transformers-5
+# compatible metadata), transformers 5.x (qwen3_5/qwen3_5_moe model types),
+# bitsandbytes (4-bit NF4 QLoRA tier). trl 1.6 requires transformers>=4.56,
+# satisfied by the 5.6+ pin; GRPOConfig is field-compatible with the 1.5 usage here.
+# Resolver/driver notes: vllm 0.17/0.18 hard-pin transformers<5 (uv refuses the
+# combo), so the first transformers-5-compatible vllm line is 0.19.1. vllm >=0.20
+# pins torch 2.11 whose default pypi wheels are CUDA-13 builds — RunPod 4090/5090
+# hosts filtered at min_cuda 12.8 often run 12.8/12.9 drivers where cu13 torch sees
+# NO GPU (observed: "cuda not available" + vLLM "cumem allocator not supported").
+# vllm 0.19.1 pins torch 2.10 (cu128 default) which matches those drivers.
+# trl's *optional* [vllm] extra caps at 0.18, but we install plain trl, so the only
+# constraint that matters is runtime API compat — validated per-model on real
+# RTX 4090/5090 workers before promotion to default (see bench/results/phase1).
+WORKER_DEPS = [
+    "torch==2.10.0",
+    "transformers>=5.6,<5.13",
+    "trl>=1.6,<1.7",
+    "peft>=0.19",
+    "vllm==0.19.1",
+    "bitsandbytes>=0.49",
+    "datasets>=4.7,<6",
+    "huggingface_hub>=0.25",
+    "accelerate>=1.4",
+    # NB: the HF `kernels` Hub package is intentionally NOT pinned here — the versions
+    # compatible with torch2.10 break transformers 5.6-5.10's hub_kernels integration at IMPORT
+    # (LayerRepository now requires a version; transformers passes none -> ValueError on every
+    # `import transformers`). FlashAttention via the Hub is therefore disabled; attention uses
+    # SDPA (already a flash/efficient backend on Ampere/Ada) + the Liger fused kernels below,
+    # which are the dominant LoRA speedup anyway. (FA via a pinned flash-attn wheel is a future
+    # per-arch experiment, kept out of the default deps to avoid a fragile cold-start install.)
+    # Liger fused Triton kernels (pure Triton -> JITs on every arch incl. Blackwell): fused
+    # linear cross-entropy for SFT (use_liger_kernel) and the chunked GRPO loss
+    # (use_liger_loss) — the big large-vocab (Qwen ~152k) memory/throughput win.
+    "wandb>=0.17",
+    "liger-kernel>=0.5",
+    # Fused Triton kernels for Gated-DeltaNet (Qwen3.5/3.6 family): without this,
+    # transformers falls back to a pure-PyTorch delta rule and GRPO trainer steps are
+    # 2-3x slower (measured A/B on Qwen3.5-2B: ~65 s/step -> ~20 s/step steady).
+    "flash-linear-attention==0.5.0",
+    # NB: fla's gated chunk_bwd is broken on HOPPER (H100) with Triton >= 3.4 (fla #640), so
+    # resolve_worker_deps DROPS fla on sm90 (the correct pure-PyTorch delta rule runs instead). The
+    # dense Qwen3.5 GDN models route to consumer cards by default, where fla works.
+]
+# NOTE on download speed: Flash's runtime already ships hf_transfer and exports
+# HF_HUB_ENABLE_HF_TRANSFER=1 on workers (measured: Qwen3-4B's ~8 GB pulled in 6.3 s,
+# NIC-saturated — bench/results/phase6). Adding hf_transfer here is redundant; don't.
+# Override the whole pinned stack per-run with AUTOSLM_WORKER_DEPS="pkgA==1 pkgB>=2"
+# (whitespace-separated, or a JSON list for specs containing commas).
+WORKER_SYSTEM_DEPS = ["build-essential"]  # Triton/Inductor need a C compiler
+
+# The prebuilt worker image (full training stack baked in; built by Dockerfile.worker /
+# .github/workflows/worker-image.yml). PUBLIC under the org namespace, so no registry login is
+# ever needed. Used on both Vast and RunPod. AUTOSLM_TRAIN_WORKER_IMAGE overrides the tag (e.g. to
+# validate a candidate image like :cu128-mgpu without overwriting the production :cu128) — read at
+# import, so set it in the control-plane env. Must be published to GHCR + public before runs pull it.
+# .strip() so a whitespace-only AUTOSLM_TRAIN_WORKER_IMAGE falls back to the default tag instead of
+# becoming an invalid Docker ref that RunPod Flash / Vast would try (and fail) to provision with.
+WORKER_IMAGE = (
+    os.environ.get("AUTOSLM_TRAIN_WORKER_IMAGE") or ""
+).strip() or "ghcr.io/freesolo-co/autoslm-worker:cu128"
+
+
+def resolve_worker_deps(friendly_gpu: str | None = None) -> list[str]:
+    """The dependency list Flash installs on the GPU worker for this run.
+
+    Precedence: AUTOSLM_WORKER_DEPS (explicit list) > the pinned ``WORKER_DEPS``.
+
+    GPU-specific: on HOPPER (sm90, H100), DROP flash-linear-attention — its gated
+    chunk_bwd Triton kernel is miscomputed there (Triton>=3.4, fla #640). Without fla,
+    transformers uses the correct pure-PyTorch delta rule (slower but correct).
+    Ampere/Ada/Blackwell keep fla for the speedup.
+    """
+    explicit = os.environ.get("AUTOSLM_WORKER_DEPS")
+    if explicit:
+        # JSON list (use this for specs containing commas, e.g.
+        # "transformers>=5.6,<5.13") or a whitespace-separated string.
+        if explicit.strip().startswith("["):
+            import json as _json
+
+            deps = [str(d).strip() for d in _json.loads(explicit) if str(d).strip()]
+        else:
+            # shlex (whitespace) splitting, NOT comma: a comma is part of a PEP 440
+            # range like `transformers>=5.6,<5.11` and must not be split.
+            import shlex
+
+            deps = [d for d in shlex.split(explicit) if d.strip()]
+        if deps:
+            return deps
+    deps = list(WORKER_DEPS)
+    # Hopper (sm90) fla strategy: DROP flash-linear-attention -> the correct pure-PyTorch delta
+    # rule. fla's gated chunk_bwd Triton kernel is miscomputed on Hopper (Triton>=3.4, fla #640),
+    # so on H100 we run without it (the dense Qwen3.5 GDN models route to consumer cards by
+    # default, where fla stays). Ampere/Ada/Blackwell keep fla for the speedup.
+    if friendly_gpu:
+        try:
+            from autoslm.providers.base import get_gpu_info
+
+            if get_gpu_info(friendly_gpu).sm == "sm90":
+                deps = [d for d in deps if not d.startswith("flash-linear-attention")]
+        except Exception:
+            pass
+    # Additive per-run extras (e.g. an extra pinned wheel for an A/B) without
+    # restating the whole pinned stack the way AUTOSLM_WORKER_DEPS requires.
+    extra = os.environ.get("AUTOSLM_WORKER_EXTRA_DEPS")
+    if extra:
+        import shlex
+
+        deps = deps + [d for d in shlex.split(extra) if d.strip()]
+    return deps
+
+
+DEFAULT_EXECUTION_TIMEOUT_MS = 6 * 3600 * 1000  # 6h RunPod worker execution cap
+
+_ENDPOINT_CACHE: dict[str, Any] = {}
+
+
+def upload_code(repo: str | None = None) -> str:
+    """Upload the ``autoslm`` package to the run's HF artifact repo.
+
+    ``repo`` is the per-run artifact repo (``spec.train.hf_repo``); the worker fetches
+    ``code/**`` from the same repo it is given in the submit payload, so the code must land in
+    that per-run repo.
+
+    The worker downloads ``code/**`` to ``/runcode``. Verifiers-only: there are no built-in
+    example environments to ship — Hub/installed envs are pip-installed on the worker (see
+    ``registry.worker_pip_for_env``).
+
+    Only the ``autoslm`` package is uploaded, NOT the client's project tree. Managed runs must
+    reference a published Hub env by ``id`` (``slm env push`` to publish a local env first); the
+    worker pip-installs the env wheel.
+    """
+    from huggingface_hub import HfApi
+
+    import autoslm
+
+    if not repo:
+        raise RuntimeError(
+            "hf_repo must be set (the run's [train] hf_repo: HF dataset repo for code + artifacts)"
+        )
+    token = os.environ.get("HF_TOKEN")
+    pkg_dir = os.path.dirname(os.path.abspath(autoslm.__file__))
+    api = HfApi(token=token)
+    # Worker pulls code/** by HTTP; HF FREE-TIER accounts cannot serve PRIVATE dataset
+    # 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)
+    # 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:
+        try:
+            api.update_repo_settings(repo_id=repo, repo_type="dataset", private=False)
+        except Exception as e:
+            logger.warning("could not ensure %s is public (free-tier worker may 403): %s", repo, e)
+    api.upload_folder(
+        folder_path=pkg_dir,
+        path_in_repo="code/autoslm",
+        repo_id=repo,
+        repo_type="dataset",
+        ignore_patterns=["__pycache__/*", "*.pyc"],
+    )
+    return repo
+
+
+def _train_body(input_data: dict) -> dict:
+    """Runs ON the RunPod GPU worker: fetch code, train (phase), return metrics.
+
+    NOTE: Flash serializes this handler and runs it standalone, so every name it uses
+    must be imported INSIDE the function body (module-level imports are not in scope).
+    """
+    import contextlib
+    import json
+    import os
+    import shutil
+    import subprocess
+    import sys
+
+    from huggingface_hub import snapshot_download
+
+    # NB: the Hopper fla guard lives in engine.worker._drop_fla_on_hopper (runs in the worker
+    # process AFTER all installs, before any model import) — doing it here would be undone by a
+    # later extra_pip / `prime env install` that pulls fla back, and depends on a handler redeploy.
+
+    # Extra pip deps for verifiers / Prime Hub environments (installed per-run).
+    extra_pip = input_data.get("extra_pip") or []
+    if extra_pip:
+        # check=True: a deterministic dependency failure should fail fast here,
+        # not after model download + worker startup with a less actionable error.
+        subprocess.run([sys.executable, "-m", "pip", "install", *extra_pip], check=True)
+
+    # NB: fla is dropped on Hopper (sm90) automatically — resolve_worker_deps omits it from the
+    # install list, and engine.worker._drop_fla_on_hopper removes any baked-in copy at worker
+    # startup (fla's GDN backward is miscomputed on sm90, #640). No env toggle: fla only ever runs
+    # on the consumer archs where its Triton kernel is correct.
+
+    # Install the run's verifiers environment(s) from the Prime Hub via the authenticated
+    # `prime` CLI. The public pip index does not serve PRIVATE env wheels, so a plain pip
+    # install can't fetch them; `prime env install` pulls/builds/installs public + private
+    # alike, authenticated by PRIME_API_KEY forwarded from the control plane.
+    hub_env_ids = input_data.get("hub_env_ids") or []
+    if hub_env_ids:
+        worker_env = {k: str(v) for k, v in (input_data.get("env") or {}).items()}
+        prime_key = worker_env.get("PRIME_API_KEY") or os.environ.get("PRIME_API_KEY")
+        if not prime_key:
+            raise RuntimeError(
+                "PRIME_API_KEY is required to install the Prime Hub environment on the worker"
+            )
+        # Only install `prime` when it isn't already on the worker (it's often baked into
+        # the worker image) — an unconditional install adds latency and a per-run PyPI
+        # failure point every run.
+        if shutil.which("prime") is None:
+            subprocess.run([sys.executable, "-m", "pip", "install", "prime"], check=True)
+        # --with pip: install the env into THIS (the trainer's) python via pip. The default
+        # (`--with uv`) installs into prime's own isolated uv env, so the trainer then can't
+        # import the env module (ModuleNotFoundError at load_environment). PIP_BREAK_SYSTEM_PACKAGES
+        # lets pip write to a PEP-668 "externally-managed" base python (the worker image's).
+        install_env = {
+            **os.environ,
+            "PRIME_API_KEY": prime_key,
+            "PRIME_DISABLE_VERSION_CHECK": "1",
+            "PIP_BREAK_SYSTEM_PACKAGES": "1",
+        }
+        for env_id in hub_env_ids:
+            subprocess.run(
+                ["prime", "env", "install", env_id, "--with", "pip"], check=True, env=install_env
+            )
+
+    overrides = {k: str(v) for k, v in (input_data.get("env") or {}).items()}
+    snapshot_download(
+        repo_id=input_data["hf_repo"],
+        repo_type="dataset",
+        allow_patterns=["code/**"],
+        local_dir="/runcode",
+        token=overrides.get("HF_TOKEN"),
+    )
+    code_dir = "/runcode/code"
+
+    env = dict(os.environ)
+    env.update(overrides)
+    # A large job_spec_json (e.g. many inline params/dataset refs) can blow past the
+    # ~128 KiB per-env-string exec limit ("Argument list too long"). Pass a large spec
+    # via a file (AUTOSLM_JOB_SPEC_PATH); keep the inline env var for small specs.
+    # load_job_spec_from_env reads either.
+    spec_json = input_data["job_spec_json"]
+    if len(spec_json) > 96_000:
+        spec_path = "/tmp/job_spec.json"
+        with open(spec_path, "w") as sf:
+            sf.write(spec_json)
+        env["AUTOSLM_JOB_SPEC_PATH"] = spec_path
+        env.pop("AUTOSLM_JOB_SPEC_JSON", None)
+    else:
+        env["AUTOSLM_JOB_SPEC_JSON"] = spec_json
+    env["PHASE"] = input_data["phase"]
+    env["SEED"] = str(input_data["seed"])
+    env["PYTHONPATH"] = code_dir + (os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else "")
+
+    def run_mode(mode: str, check: bool) -> int:
+        """Run one worker process, tee its console to a file, and on failure upload the
+        tail to HF as console_<mode>.txt — the engine-core root cause of crashes like
+        vLLM EngineDeadError only ever appears on the subprocess console, never in the
+        Python traceback."""
+        console = f"/tmp/console_{mode}.txt"
+        with open(console, "w") as cf:
+            proc = subprocess.Popen(
+                [sys.executable, "-m", "autoslm.engine.worker"],
+                cwd=code_dir,
+                env={**env, "RUN_MODE": mode},
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+            )
+            for line in proc.stdout:
+                print(line, end="")  # keep streaming to the platform console
+                cf.write(line)
+            proc.wait()
+        if proc.returncode != 0:
+            try:
+                from huggingface_hub import HfApi
+
+                spec = json.loads(input_data["job_spec_json"])
+                phase_ns = "rl" if spec.get("algorithm") == "grpo" else spec["algorithm"]
+                prefix = f"{phase_ns}/{spec['run_id']}/seed{input_data['seed']}"
+                with open(console) as f:
+                    tail = f.read()[-64_000:]
+                with open(console + ".tail", "w") as f:
+                    f.write(tail)
+                HfApi(token=env.get("HF_TOKEN")).upload_file(
+                    path_or_fileobj=console + ".tail",
+                    path_in_repo=f"{prefix}/console_{mode}.txt",
+                    repo_id=input_data["hf_repo"],
+                    repo_type="dataset",
+                )
+            except Exception as up_err:
+                print("console upload warn:", up_err)
+            if check:
+                raise RuntimeError(
+                    f"worker mode '{mode}' exited {proc.returncode}; see console_{mode}.txt "
+                    f"and error_{mode}.txt in the HF dataset repo"
+                )
+        return proc.returncode
+
+    # A warm worker can carry a previous seed's metrics files; a stale metrics.json
+    # would let a crashed train phase report the previous run's numbers. Clear before
+    # training.
+    for stale in ("/tmp/train_meta.json", "/tmp/metrics.json"):
+        with contextlib.suppress(FileNotFoundError):
+            os.remove(stale)
+    # Train. check=False — RL's colocated vLLM can segfault at interpreter exit AFTER
+    # the adapter + metrics.json + DONE are saved; don't treat that as a failure.
+    run_mode(input_data["phase"], check=False)
+    # The train phase writes metrics.json + the DONE sentinel itself (RunPod can also
+    # redeliver a completed job, whose worker restores metrics.json from DONE). If it
+    # is missing, the train phase crashed before finishing — fail fast with the real
+    # cause (full traceback in error_<phase>.txt / console_<phase>.txt in the HF repo).
+    if not os.path.exists("/tmp/metrics.json"):
+        phase = input_data["phase"]
+        raise RuntimeError(
+            f"train phase '{phase}' produced no /tmp/metrics.json (it crashed before "
+            f"finishing); see error_{phase}.txt and console_{phase}.txt in the HF "
+            f"dataset repo for the full traceback"
+        )
+    with open("/tmp/metrics.json") as f:
+        return json.load(f)
+
+
+def isolate_flash_state(scope: str | None = None) -> None:
+    """Point the Flash SDK's resource registry at a per-process/private directory.
+
+    The SDK persists its registry to ``./.flash/resources.pkl`` — shared, whole-dict,
+    last-writer-wins across every process in the CWD. Observed failure modes: stale
+    entries resurrecting long-dead endpoints on later syncs, and concurrent processes
+    clobbering each other's bookkeeping. Each AutoSLM process gets its own registry
+    under ``~/.autoslm/flash-state/<scope>``; remote cleanup never relies on the
+    registry anyway (REST by id/name — see api.py).
+    """
+    try:
+        from pathlib import Path
+
+        import runpod_flash.core.resources.resource_manager as rm
+
+        scope = scope or f"pid{os.getpid()}"
+        state_dir = Path.home() / ".autoslm" / "flash-state" / scope
+        state_dir.mkdir(parents=True, exist_ok=True)
+        rm.FLASH_STATE_DIR = state_dir
+        rm.RESOURCE_STATE_FILE = state_dir / "resources.pkl"
+    except Exception as exc:  # never block a run on this
+        logger.warning("flash state isolation skipped: %s", exc)
+
+
+def _patch_runpod_backoff() -> None:
+    """Work around a runpod_flash bug that aborts long-running jobs.
+
+    The SDK polls a synchronous job with exponential backoff computed as
+    ``base * (2 ** attempt)`` and only clamps to ``max_seconds`` afterwards. On a long
+    run the poll ``attempt`` grows without bound, so ``2 ** attempt`` becomes a huge int
+    and the float multiply raises ``OverflowError: int too large to convert to float``
+    (observed ~80 min in), killing an otherwise-healthy job mid-run. We patch the symbol
+    to cap the exponent before the power so the delay still saturates at ``max_seconds``.
+    """
+    try:
+        import math
+        import random
+
+        from runpod_flash.core.utils import backoff as _bo
+
+        if getattr(_bo, "_autoslm_backoff_patched", False):
+            return
+
+        def _safe_get_backoff_delay(
+            attempt,
+            base=0.1,
+            max_seconds=10.0,
+            jitter=0.2,
+            strategy=_bo.BackoffStrategy.EXPONENTIAL,
+        ):
+            a = min(int(attempt), 30)  # cap exponent: 2**30 is plenty; delay saturates anyway
+            if strategy == _bo.BackoffStrategy.EXPONENTIAL:
+                delay = base * (2**a)
+            elif strategy == _bo.BackoffStrategy.LINEAR:
+                delay = base + (attempt * base)
+            elif strategy == _bo.BackoffStrategy.LOGARITHMIC:
+                delay = base * math.log2(attempt + 2)
+            else:
+                raise ValueError(f"Unsupported backoff strategy: {strategy}")
+            delay = min(delay, max_seconds)
+            return delay * random.uniform(1 - jitter, 1 + jitter)
+
+        _bo.get_backoff_delay = _safe_get_backoff_delay
+        _bo._autoslm_backoff_patched = True
+        # serverless.py did `from ..utils.backoff import get_backoff_delay`, so patch its ref too.
+        try:
+            from runpod_flash.core.resources import serverless as _sl
+
+            _sl.get_backoff_delay = _safe_get_backoff_delay
+        except Exception:
+            # serverless.py may not import the symbol in this SDK version; the primary
+            # patch above still applies, so a missing alias is fine to ignore.
+            pass
+    except Exception as exc:  # never let the patch break submission
+        logger.warning("runpod backoff patch skipped: %s", exc)
+
+
+def min_cuda_for(friendly_gpu: str) -> str:
+    """Minimum host CUDA (driver) version for this GPU class on the active stack.
+
+    Blackwell classes (sm_120 — RTX 5090, RTX Pro 6000): pypi wheels for
+    the modern stack (vllm 0.19) ship no Blackwell SASS, so every custom CUDA kernel
+    is PTX-JIT'd by the driver — and their PTX is built with a newer toolchain than
+    CUDA-12.8-era drivers can JIT (observed: "the provided PTX was compiled with an
+    unsupported toolchain" on driver 570.x). CUDA-13 drivers JIT it fine, so those
+    classes are pinned to >=13.0 on the modern stack (per-GPU ``min_cuda_modern`` in
+    providers.base.GPU_INFO). Ampere/Ada/Hopper have SASS in the wheels and run on 12.8.
+    Override with AUTOSLM_MIN_CUDA.
+    """
+    explicit = os.environ.get("AUTOSLM_MIN_CUDA")
+    if explicit:
+        return explicit
+    from autoslm.providers.base import min_cuda_modern
+
+    return min_cuda_modern(friendly_gpu)
+
+
+def endpoint_name(friendly_gpu: str, suffix: str | None = None) -> str:
+    """Flash endpoint/template name for a GPU class, optionally made unique per run.
+
+    A fixed name (``autoslm-train-5090``) collides across back-to-back runs: runpod_flash's
+    ``get_or_deploy_resource`` finds the prior run's still-registered resource and tries to
+    *update* it, which fails with ``GraphQL errors: Template name must be unique`` (there is
+    no endpoint GC/reuse). A per-run ``suffix`` (the run id tail) gives each run its own
+    endpoint so it deploys fresh instead of colliding. RunPod scales each to zero when idle.
+    """
+    base = f"autoslm-train-{gpu_short(friendly_gpu)}"
+    if not suffix:
+        return base
+    safe = "".join(c for c in str(suffix) if c.isalnum() or c == "-").strip("-")[:24]
+    return f"{base}-{safe}" if safe else base
+
+
+def get_train_endpoint(
+    friendly_gpu: str,
+    execution_timeout_ms: int | None = None,
+    name_suffix: str | None = None,
+    disk_gb: int | None = None,
+    spec=None,
+):
+    """Build (and cache) the live Flash endpoint handler for a GPU class."""
+    # Live ("ad-hoc") provisioning: provision on call, no separate `flash deploy`.
+    os.environ["FLASH_IS_LIVE_PROVISIONING"] = "true"
+    from runpod_flash import Endpoint
+
+    from autoslm.providers.runpod.auth import ensure_auth
+    from autoslm.providers.runpod.jobs import volume_endpoint_kwargs
+
+    ensure_auth()
+    _patch_runpod_backoff()
+    isolate_flash_state(name_suffix)
+
+    friendly = canonical_gpu(friendly_gpu)
+    name = endpoint_name(friendly, name_suffix)
+    if name in _ENDPOINT_CACHE:
+        return _ENDPOINT_CACHE[name]
+    kwargs = dict(
+        name=name,
+        gpu=flash_gpu(friendly),
+        # GPUs per worker (= trainer + inference_gpus); >1 for disaggregated async GRPO, else 1.
+        gpu_count=max(1, int(getattr(getattr(spec, "gpu", None), "count", 1))),
+        min_cuda_version=min_cuda_for(friendly),
+        execution_timeout_ms=execution_timeout_ms or DEFAULT_EXECUTION_TIMEOUT_MS,
+        workers=(0, 1),  # one dedicated worker per run; scale to zero when idle
+        **volume_endpoint_kwargs(spec),
+    )
+    # Prebuilt worker image (deps baked in) cuts the cold-start dep install. It's PUBLIC, so no
+    # registry login is needed. If WORKER_IMAGE is ever blanked, fall back to installing
+    # WORKER_DEPS on first use (cached as a Flash artifact across calls).
+    if WORKER_IMAGE:
+        kwargs["image"] = WORKER_IMAGE
+    else:
+        kwargs["dependencies"] = resolve_worker_deps(friendly)
+        kwargs["system_dependencies"] = WORKER_SYSTEM_DEPS
+    ep = Endpoint(**kwargs)
+    handler = ep(_train_body)  # register the queue-based handler; returns the callable
+    # The resource config is cached on the Endpoint, so raising the disk on it here
+    # carries through to the deploy that the first handler call triggers.
+    from autoslm.providers.runpod.jobs import apply_disk_gb
+
+    cfg = ep._build_resource_config()
+    apply_disk_gb(cfg, disk_gb)
+    _ENDPOINT_CACHE[name] = handler
+    return handler
+
+
+def _run_suffix(run_id: str | None) -> str | None:
+    """Short, COLLISION-FREE per-run endpoint suffix.
+
+    Must be unique per run_id: the endpoint name is ``endpoint_name(friendly, suffix)`` and
+    RunPod reuses an endpoint by name -- two runs with the same suffix share one endpoint (and
+    its cached image/deps/registry-auth/template), so a later run silently reuses the earlier
+    one's config. The old ``run_id.split("-")[-1]`` only worked for hash-tailed default ids; a
+    descriptive run_id ending in e.g. the card name (``...-a100``) collided across every run.
+    Use a stable short hash of the WHOLE run_id, with a sanitized prefix for readability."""
+    if not run_id:
+        return None
+    import hashlib
+    import re
+
+    h = hashlib.sha1(run_id.encode()).hexdigest()[:8]
+    prefix = re.sub(r"[^a-z0-9]", "", run_id.lower())[-12:]
+    return f"{prefix}{h}" if prefix else h
+
+
+def stop_endpoint(friendly_gpu: str, name: str | None = None) -> None:
+    """Best-effort: scale cached endpoint(s) to zero / drop them.
+
+    With ``name`` only that run's cached endpoint is dropped; without it, every
+    cached endpoint of the GPU class is — so a per-run teardown passes ``name``
+    to avoid evicting a concurrent run's handler in the same process.
+
+    NOTE: this only touches THIS process's in-memory cache, so it does nothing in a fresh
+    ``slm cancel`` process. Use ``terminate_endpoint`` to actually delete the remote endpoint.
+    """
+    friendly = canonical_gpu(friendly_gpu)
+    prefix = f"autoslm-train-{gpu_short(friendly)}"
+    if name:
+        match = [k for k in _ENDPOINT_CACHE if k == name]
+    else:
+        match = [k for k in _ENDPOINT_CACHE if k.startswith(prefix)]
+    for key in match:
+        handler = _ENDPOINT_CACHE.pop(key, None)
+        ep = getattr(handler, "__self__", None) or getattr(handler, "endpoint", None)
+        for meth in ("scale_to_zero", "stop", "delete"):
+            fn = getattr(ep, meth, None)
+            if callable(fn):
+                try:
+                    fn()
+                    break
+                except Exception:
+                    continue
+
+
+def _select_endpoint_resources(resources: dict, target: str) -> list[str]:
+    """Resource ids whose resource ``.name`` contains ``target``.
+
+    The live-provisioned resource is named ``live-<endpoint_name>``, so we match by substring
+    to catch the prefix. ``target`` is the endpoint name (``autoslm-train-<gpu>[-<run>]``).
+    """
+    if not target:
+        return []
+    out = []
+    for uid, res in (resources or {}).items():
+        name = str(getattr(res, "name", "") or "")
+        if target in name:
+            out.append(uid)
+    return out
+
+
+def terminate_endpoint(friendly_gpu: str, run_id: str | None = None) -> list[dict]:
+    """Reliably tear down the remote Flash endpoint(s) for a run — cross-process.
+
+    Unlike ``stop_endpoint`` (which only touches this process's in-memory cache), this looks
+    the endpoint up by name in runpod_flash's *persisted* resource registry and deletes it via
+    the RunPod API (``ResourceManager.undeploy_resource`` -> ``delete_endpoint``), which stops
+    any running worker. Best-effort: never raises. Returns the per-resource undeploy results.
+
+    With ``run_id`` it targets exactly that run's uniquely-named endpoint; without it, the
+    bare ``autoslm-train-<gpu>`` prefix matches every endpoint of that GPU class.
+    """
+    friendly = canonical_gpu(friendly_gpu)
+    target = endpoint_name(friendly, _run_suffix(run_id))
+    # Hold FLASH_SDK_LOCK across the ENTIRE Flash critical section, not just the undeploy.
+    # isolate_flash_state() swaps runpod_flash's process-wide registry globals and
+    # ResourceManager shares the SDK's asyncio singleton, so a concurrent deploy/undeploy on
+    # another thread could swap the registry scope between our lookup and our undeploy and tear
+    # down the wrong run's resources. Serialize isolation + lookup + undeploy together.
+    with FLASH_SDK_LOCK:
+        try:
+            from autoslm.providers.runpod.auth import ensure_auth
+
+            ensure_auth()
+            isolate_flash_state(_run_suffix(run_id))
+            from runpod_flash.core.resources.resource_manager import ResourceManager
+        except Exception as exc:  # SDK/auth unavailable
+            return [{"success": False, "name": target, "message": f"flash unavailable: {exc}"}]
+
+        try:
+            rm = ResourceManager()
+            resources = rm.list_all_resources()
+            uids = _select_endpoint_resources(resources, target)
+        except Exception as exc:
+            return [{"success": False, "name": target, "message": f"resource lookup failed: {exc}"}]
+
+        async def _undeploy_all() -> list:
+            out = []
+            for uid in uids:
+                res = resources.get(uid)
+                name = getattr(res, "name", None)
+                try:
+                    out.append(
+                        await rm.undeploy_resource(uid, resource_name=name, force_remove=True)
+                    )
+                except Exception as exc:
+                    out.append({"success": False, "name": name, "message": str(exc)})
+            return out
+
+        try:
+            results = asyncio.run(_undeploy_all())
+        except Exception as exc:
+            results = [{"success": False, "name": target, "message": str(exc)}]
+
+    # Registry-less fallback: isolate_flash_state() keeps the Flash SDK's resource
+    # registry per-process under ~/.autoslm, so a recreated container (or a crash before
+    # on_handle() persisted the endpoint id) leaves the live endpoint invisible to the
+    # lookup above. Delete it via the RunPod REST API by its reconstructed name so it
+    # can't keep a paid worker alive.
+    if not uids:
+        with contextlib.suppress(Exception):
+            from autoslm.providers.runpod import api as runpod_api
+
+            for ep in runpod_api.find_endpoints_by_name(target):
+                if ep.get("name") == target and runpod_api.delete_endpoint(ep["id"]):
+                    results.append(
+                        {"success": True, "name": target, "message": "deleted via REST API"}
+                    )
+
+    # also drop the in-process cached handler for THIS run only (a class-wide
+    # drop would evict a concurrent run's endpoint on the same GPU class).
+    with contextlib.suppress(Exception):
+        stop_endpoint(friendly, name=target)
+    return results
+
+
+def build_worker_env(spec: JobSpec, seed: int) -> dict:
+    """Per-run env passed to the worker (secrets + recipe overrides)."""
+    # CUDA allocator conf. Colocate (TRL trainer + vLLM on one GPU) fragments over a long run,
+    # so expandable_segments (which reclaims fragmentation) is the right default — EXCEPT under
+    # GRPO vLLM sleep mode, whose CuMemAllocator memory pool is incompatible with
+    # expandable_segments (vLLM asserts and the run crashes at engine init). So for RL with
+    # sleep mode ON (the default), default to a non-expandable conf instead; SFT and
+    # sleep-off RL keep expandable_segments. An explicit operator override always wins.
+    _is_rl = str(getattr(spec, "algorithm", "")).lower() not in ("sft",)
+    # RL_VLLM_SLEEP may be pinned per-run via [worker_env] (highest precedence, merged into the
+    # worker env later) OR via the control-plane process env. Resolve it from BOTH here — with
+    # worker_env winning — so a per-run explicit pin counts as explicit: otherwise _sleep_set stays
+    # false, AUTOSLM_ALLOC_AUTO=1 is sent, and the worker can upgrade to expandable_segments while
+    # run_rl still enables vLLM sleep, hitting the CuMemAllocator incompatibility after provisioning.
+    _sleep_raw = (spec.worker_env or {}).get("RL_VLLM_SLEEP", os.environ.get("RL_VLLM_SLEEP"))
+    _sleep_set = _sleep_raw is not None
+    _sleep_on = (_sleep_raw if _sleep_raw is not None else "1") not in ("0", "false", "False")
+    _alloc_default = (
+        "garbage_collection_threshold:0.8,max_split_size_mb:256"
+        if (_is_rl and _sleep_on)
+        else "expandable_segments:True"
+    )
+    # torch >= 2.10 renamed the env to PYTORCH_ALLOC_CONF — set BOTH names for either stack.
+    _alloc_override = os.environ.get("PYTORCH_ALLOC_CONF") or os.environ.get(
+        "PYTORCH_CUDA_ALLOC_CONF"
+    )
+    _alloc_conf = _alloc_override or _alloc_default
+    env: dict[str, str] = {
+        "RUN_ID": spec.run_id,
+        # Compute substrate, read back by engine.worker for the RunMetrics record. Vast's
+        # on-instance bootstrap overrides this to "vast" (it reuses this same env builder).
+        "AUTOSLM_ARM": "runpod",
+        # GPUs provisioned on the node (= trainer + inference_gpus). The worker reads this
+        # (engine.disaggregated.detect_total_gpus) to compute the disaggregated rollout split
+        # WITHOUT initializing a torch CUDA context first. 1 = single-GPU (colocate).
+        "AUTOSLM_GPU_COUNT": str(max(1, int(getattr(spec.gpu, "count", 1)))),
+        "BENCH_HF_MODEL": spec.model,
+        "PYTORCH_CUDA_ALLOC_CONF": _alloc_conf,
+        "PYTORCH_ALLOC_CONF": _alloc_conf,
+        # We picked a DEFAULT alloc conf above without knowing the worker's resolved vLLM sleep
+        # decision (RL + RL_VLLM_SLEEP unset + no operator override). Cede the final choice to the
+        # worker, which resolves sleep from the model config and upgrades to expandable_segments
+        # when sleep is OFF (engine.worker.finalize_alloc_conf_for_sleep). Never set when the
+        # operator pinned an alloc conf or RL_VLLM_SLEEP explicitly — their choice is authoritative.
+        **(
+            {"AUTOSLM_ALLOC_AUTO": "1"}
+            if (_is_rl and not _sleep_set and not _alloc_override)
+            else {}
+        ),
+        # Escape hatch for torch.compile/inductor spikes (Qwen3.5 DeltaNet kernels
+        # compile at first forward and can OOM a tight colocate budget).
+        **(
+            {"TORCHDYNAMO_DISABLE": os.environ["TORCHDYNAMO_DISABLE"]}
+            if os.environ.get("TORCHDYNAMO_DISABLE")
+            else {}
+        ),
+    }
+    # HF artifact creds + PRIME_API_KEY (the worker `prime env install`s the run's Hub
+    # env(s), public + private) + optional reward-judge creds: a verifiers env whose rubric
+    # calls an LLM judge (e.g. OpenRouter gpt-oss-120b) needs the API key ON THE WORKER,
+    # where the reward runs. Forward any that the operator has set; absent ones are simply
+    # not passed.
+    for key in (
+        "HF_TOKEN",
+        "PRIME_API_KEY",
+        "OPENROUTER_API_KEY",
+        "OPENAI_API_KEY",
+    ):
+        if os.environ.get(key):
+            env[key] = os.environ[key]
+    # Seed the worker's own HF_REPO env from the run's [train] hf_repo (adapter/checkpoint/
+    # code storage + heartbeats). The worker reads HF_REPO from its own process env; that env
+    # is now sourced from the spec, not the operator's HF_REPO.
+    env["HF_REPO"] = spec.train.hf_repo
+    # Opt-in network volume: point the whole HF cache at the persistent mount so
+    # model weights survive across runs (the download becomes a one-time cost per
+    # volume instead of per run).
+    if getattr(spec.gpu, "network_volume", None):
+        env["HF_HOME"] = "/runpod-volume/hf-cache"
+    if spec.train.steps is not None:
+        env["RL_STEPS"] = str(spec.train.steps)
+    if spec.train.epochs is not None:
+        env["SFT_EPOCHS"] = str(spec.train.epochs)
+    # Forward the documented worker-tuning knobs so they actually reach the GPU worker.
+    # RL_VLLM_GPU_UTIL / RL_PER_DEVICE_PROMPTS are the colocate-memory knobs the docs tell
+    # users to set to fix vLLM OOM/KV-cache errors; they were previously dropped here.
+    for k in (
+        "SFT_PER_DEVICE_BS",
+        "SFT_PACKING",
+        # Colocate-memory knobs the docs tell users to set to fix vLLM OOM / KV-cache errors.
+        "RL_VLLM_GPU_UTIL",
+        "RL_VLLM_SLEEP",
+        "RL_PER_DEVICE_PROMPTS",
+        "VLLM_USE_V1",
+        # Attention-backend escape hatch: vllm's bundled flash-attn PTX can be newer
+        # than the host driver's JIT (sm_120 + 12.8 drivers); TRITON_ATTN/FLASHINFER
+        # sidestep it without restricting the host pool to CUDA-13 drivers.
+        "VLLM_ATTENTION_BACKEND",
+        "AUTOSLM_QUANT",
+        "WANDB_API_KEY",
+        "WANDB_ENTITY",
+        "LORA_TARGETS",
+    ):
+        # Forward when SET, even if empty: an explicit "" is a meaningful override.
+        if os.environ.get(k) is not None:
+            env[k] = os.environ[k]
+    # Per-run worker_env overrides win over the global os.environ allowlist: this is what lets
+    # ONE run differ (e.g. a per-run optimizer or LoRA-init A/B) while every other concurrent run
+    # keeps the global default.
+    for k, v in (getattr(spec, "worker_env", None) or {}).items():
+        env[str(k)] = str(v)
+    return env
+
+
+def submit_train(spec: JobSpec, seed: int, log=None) -> dict:
+    """Provision a dedicated GPU via Flash, run training, return the metrics dict."""
+    timeout_s = max(60, int(spec.gpu.max_wall_seconds))
+    from autoslm.envs.registry import worker_hub_env_ids, worker_pip_for_env
+
+    handler = get_train_endpoint(
+        spec.gpu.type,
+        execution_timeout_ms=timeout_s * 1000,
+        name_suffix=_run_suffix(spec.run_id),
+        disk_gb=spec.gpu.disk_gb,
+        spec=spec,
+    )
+    payload = {
+        "hf_repo": spec.train.hf_repo,
+        "job_spec_json": spec.to_json(),
+        "phase": spec.phase,
+        "seed": int(seed),
+        "env": build_worker_env(spec, seed),
+        "extra_pip": list(spec.environment.pip) or worker_pip_for_env(spec.environment.id),
+        "hub_env_ids": worker_hub_env_ids(spec.environment.id, spec.environment.params),
+    }
+    if log is not None:
+        print(
+            f"submitting Flash job: gpu={spec.gpu.type} phase={spec.phase} "
+            f"seed={seed} model={spec.model}",
+            file=log,
+            flush=True,
+        )
+
+    async def _call():
+        res = handler(payload)
+        if inspect.isawaitable(res):
+            res = await res
+        return res
+
+    out = asyncio.run(_call())
+    if not isinstance(out, dict):
+        raise RuntimeError(f"flash job returned no metrics: {out!r}")
+    return out

code/autoslm/providers/vast/__init__.py

@@ -0,0 +1,124 @@
+"""Vast.ai provider: verified-datacenter single-GPU instances (REST only).
+
+The Vast substrate rents a single-GPU instance from a verified-datacenter offer, ships
+a self-contained bootstrap through the onstart script, and detects completion purely
+from the worker's HF artifacts (no inbound network, no serverless queue). It implements
+the SAME ``base.Provider`` interface behind the SAME module layout as RunPod, so the
+orchestrator/allocator treat the two interchangeably.
+
+``PROVIDER`` is the ``base.Provider`` implementation the registry hands out.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from autoslm.providers.base import GpuClass, JobHandle, PollResult, Provider
+
+
+class VastProvider:
+    """``base.Provider`` for the Vast.ai verified-datacenter substrate."""
+
+    name = "vast"
+
+    def is_configured(self) -> bool:
+        from autoslm.providers.vast.auth import load_api_key
+
+        # Vast needs its operator key AND a live network path: it is a live-market
+        # substrate (offer search), so AUTOSLM_SKIP_NET (offline/CI) disables Vast
+        # entirely; offline allocation then degrades deterministically to RunPod's
+        # static catalog.
+        if os.environ.get("AUTOSLM_SKIP_NET"):
+            return False
+        return load_api_key() is not None
+
+    def preflight(self, require_hf: bool = True) -> list[str]:
+        from autoslm.providers.vast.preflight import missing_credentials
+
+        return missing_credentials(require_hf=require_hf)
+
+    def gpu_classes(self) -> list[GpuClass]:
+        from autoslm.providers.vast.gpus import gpu_classes
+
+        return gpu_classes()
+
+    def hourly_rate(self, gpu: str) -> float:
+        from autoslm.providers.vast.pricing import hourly_rate
+
+        return hourly_rate(gpu)
+
+    def submit_run(
+        self,
+        spec,
+        seed: int,
+        *,
+        log: Any = None,
+        on_handle: Any = None,
+        attempt: int = 0,
+        offers: Any = None,
+        exclude_machine_ids: Any = frozenset(),
+    ) -> PollResult:
+        from autoslm.providers.vast.jobs import submit_run_vast
+
+        return submit_run_vast(
+            spec,
+            seed,
+            log=log,
+            on_handle=on_handle,
+            attempt=attempt,
+            offers=offers,
+            exclude_machine_ids=exclude_machine_ids,
+        )
+
+    def poll(self, handle: JobHandle, spec, seed: int, *, log: Any = None) -> PollResult:
+        from autoslm.providers.runpod.jobs import make_hf_heartbeat_reader
+        from autoslm.providers.vast.jobs import VastJobHandle, poll_vast_job
+
+        hf_repo = spec.train.hf_repo
+        prefix = f"{spec.phase}/{spec.run_id}/seed{seed}"
+        reader = make_hf_heartbeat_reader(hf_repo, prefix) if hf_repo else None
+        vh = VastJobHandle.from_dict(handle.to_dict())
+        if log is not None:
+            print(f"attaching: vast instance={vh.instance_id}", file=log, flush=True)
+        # Reattach must apply the SAME stall tuning + wall-cap deadline as submit_run_vast
+        # (see jobs.py), mirroring RunPod's reattach (runpod/__init__.py). Vast has no
+        # server-side execution timeout, so a recovered run that dropped the client-side
+        # deadline could bill unbounded.
+        stall = 1500.0
+        deadline = max(60, int(spec.gpu.max_wall_seconds)) + 1800
+        return poll_vast_job(
+            vh,
+            spec,
+            seed,
+            log=log,
+            heartbeat_reader=reader,
+            stall_after_s=stall,
+            deadline_s=deadline,
+        )
+
+    def cancel(self, handle: JobHandle) -> None:
+        from autoslm.providers.vast.jobs import cancel
+
+        cancel(handle.to_dict())
+
+    def destroy(self, handle: JobHandle) -> None:
+        from autoslm.providers.vast import api as vast_api
+
+        d = handle.to_dict()
+        if d.get("instance_id"):
+            vast_api.destroy_instance(int(d["instance_id"]))
+
+    def gc(self, spec) -> None:
+        from autoslm.providers.vast.jobs import destroy_run_instances
+
+        destroy_run_instances(spec.run_id)
+
+    def sweep_orphans(self, active_labels: set[str] | None = None) -> list[int]:
+        """Vast-only crash-recovery sweep (called via the provider object at startup)."""
+        from autoslm.providers.vast.jobs import sweep_orphans
+
+        return sweep_orphans(active_labels=active_labels)
+
+
+PROVIDER: Provider = VastProvider()

code/autoslm/providers/vast/_bootstrap.py

@@ -0,0 +1,274 @@
+"""Self-contained bootstrap that runs ON a Vast.ai instance.
+
+Replicates ``providers/runpod/train.py:_train_body`` semantics on the Vast substrate: install
+extra pip deps, fetch the autoslm package from the HF dataset repo, then run the
+substrate-neutral worker (``autoslm.engine.worker``) to train, uploading the console
+tail on failure. There is NO return channel
+from the instance: the worker's HF artifacts (DONE/metrics.json/heartbeat.json) are
+the success signal, and this bootstrap's attempt-scoped ``vast_attempt<N>.json`` is
+the terminal marker the control plane keys failures on.
+
+This file is shipped verbatim inside the instance's onstart script (see
+``providers/vast/jobs.py:build_onstart``), so it must stay self-contained: stdlib +
+huggingface_hub (installed with the worker deps) only — never import autoslm here.
+It reads its payload from ``/root/autoslm/payload.json``.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import threading
+import time
+
+PAYLOAD_PATH = "/root/autoslm/payload.json"
+CODE_ROOT = "/runcode"
+CODE_DIR = "/runcode/code"
+
+
+def load_payload(path: str = PAYLOAD_PATH) -> dict:
+    with open(path) as f:
+        return json.load(f)
+
+
+def hf_upload(payload: dict, local_path: str, repo_subpath: str) -> None:
+    """Upload one artifact under the run's HF prefix; never raises."""
+    try:
+        from huggingface_hub import HfApi
+
+        HfApi(token=(payload.get("env") or {}).get("HF_TOKEN")).upload_file(
+            path_or_fileobj=local_path,
+            path_in_repo=f"{payload['hf_prefix']}/{repo_subpath}",
+            repo_id=payload["hf_repo"],
+            repo_type="dataset",
+        )
+    except Exception as exc:
+        print(f"hf upload warn ({repo_subpath}): {exc}", flush=True)
+
+
+def build_worker_env(payload: dict) -> dict:
+    env = dict(os.environ)
+    env.update({k: str(v) for k, v in (payload.get("env") or {}).items()})
+    # Pass a large spec via a file, not the environment: a job spec with large inline
+    # params can reach multiple hundred KB, and that big an env var trips execve's
+    # "Argument list too long" when the worker subprocess starts. Mirrors
+    # runpod/train.py:_train_body.
+    spec_json = payload["job_spec_json"]
+    if len(spec_json) > 96_000:
+        with open("/tmp/job_spec.json", "w") as f:
+            f.write(spec_json)
+        env["AUTOSLM_JOB_SPEC_PATH"] = "/tmp/job_spec.json"
+        env.pop("AUTOSLM_JOB_SPEC_JSON", None)
+    else:
+        env["AUTOSLM_JOB_SPEC_JSON"] = spec_json
+    env["PHASE"] = payload["phase"]
+    env["SEED"] = str(payload["seed"])
+    # Compute substrate for the RunMetrics record (engine.worker reads AUTOSLM_ARM). The
+    # payload env was built by the shared runpod env builder, which stamps "runpod"; this
+    # bootstrap runs on the Vast instance, so override it to the real backend.
+    env["AUTOSLM_ARM"] = "vast"
+    env["PYTHONPATH"] = CODE_DIR + (os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else "")
+    return env
+
+
+def fetch_code(payload: dict) -> None:
+    from huggingface_hub import snapshot_download
+
+    snapshot_download(
+        repo_id=payload["hf_repo"],
+        repo_type="dataset",
+        allow_patterns=["code/**"],
+        local_dir=CODE_ROOT,
+        token=(payload.get("env") or {}).get("HF_TOKEN"),
+    )
+
+
+def run_mode(payload: dict, env: dict, mode: str, deadline_ts: float) -> int:
+    """One worker process; console teed to a file and streamed to the instance log.
+
+    On failure the console tail is uploaded as console_<mode>.txt — like _train_body,
+    because subprocess consoles are the only place engine-core crashes surface. On
+    deadline the process is killed and we return a sentinel nonzero rc.
+    """
+    console = f"/tmp/console_{mode}.txt"
+    timed_out = False
+    with open(console, "w") as cf:
+        proc = subprocess.Popen(
+            [sys.executable, "-m", "autoslm.engine.worker"],
+            cwd=CODE_DIR,
+            env={**env, "RUN_MODE": mode},
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+
+        def pump():
+            for line in proc.stdout:
+                print(line, end="", flush=True)
+                cf.write(line)
+
+        t = threading.Thread(target=pump, daemon=True)
+        t.start()
+        try:
+            proc.wait(timeout=max(10.0, deadline_ts - time.time()))
+        except subprocess.TimeoutExpired:
+            timed_out = True
+            proc.kill()
+            proc.wait()
+        t.join(timeout=10)
+    if proc.returncode != 0 or timed_out:
+        try:
+            tail_path = console + ".tail"
+            with open(console) as f:
+                tail = f.read()[-64_000:]
+            if timed_out:
+                tail += f"\n--- bootstrap: mode '{mode}' hit the wall-clock cap; killed ---\n"
+            with open(tail_path, "w") as f:
+                f.write(tail)
+            hf_upload(payload, tail_path, f"console_{mode}.txt")
+        except Exception as exc:
+            print(f"console upload warn: {exc}", flush=True)
+    if timed_out:
+        raise TimeoutError(f"worker mode '{mode}' exceeded the wall-clock cap")
+    return proc.returncode
+
+
+def write_attempt_marker(payload: dict, ok: bool, error: str = "") -> None:
+    """Attempt-scoped terminal marker: how the control plane distinguishes THIS
+    attempt's failure from a prior attempt's leftovers under the same prefix."""
+    marker = {
+        "ok": bool(ok),
+        "ts": time.time(),
+        "attempt": int(payload.get("attempt") or 0),
+        "error": error[:2000],
+    }
+    p = "/tmp/vast_attempt.json"
+    with open(p, "w") as f:
+        json.dump(marker, f)
+    hf_upload(payload, p, f"vast_attempt{marker['attempt']}.json")
+
+
+def main() -> int:
+    # Make SIGTERM (vast stop / bash `timeout`) unwind through finally so the
+    # terminal marker still gets uploaded.
+    signal.signal(signal.SIGTERM, lambda *a: sys.exit(1))
+    payload = load_payload()
+    ok = False
+    error = ""
+    try:
+        # Fast model downloads on Vast: RunPod's Flash runtime ships hf_transfer + sets
+        # HF_HUB_ENABLE_HF_TRANSFER, but Vast hosts don't — so a cold model pull is serial and
+        # slow (measured ~84s for a 2 GB model vs ~6s on RunPod, where setup is now the dominant
+        # cost). Install it + enable so snapshot_download/from_pretrained saturate the NIC.
+        # Best-effort: only enable the flag if the package is present (enabling it WITHOUT the
+        # package makes huggingface_hub hard-error).
+        try:
+            import importlib.util
+
+            if importlib.util.find_spec("hf_transfer") is None:
+                subprocess.run([sys.executable, "-m", "pip", "install", "hf_transfer"], check=True)
+            os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+        except Exception as _e:
+            print("hf_transfer setup skipped (slow downloads):", _e)
+        # W&B logging (restored post-autoslm-migration): the prebuilt image predates wandb being
+        # added to the stack, so install it on-demand when a W&B key is present. The worker's
+        # wandb_report_to() gates report_to on the package actually importing, so this is what makes
+        # W&B logging real on the current image without a rebuild.
+        try:
+            import importlib.util  # local: the hf_transfer block above may fail before importing it
+
+            _penv = payload.get("env") or {}
+            if (_penv.get("WANDB_API_KEY") or os.environ.get("WANDB_API_KEY")) and (
+                importlib.util.find_spec("wandb") is None
+            ):
+                subprocess.run([sys.executable, "-m", "pip", "install", "wandb>=0.17"], check=False)
+                print("[wandb] installed wandb on-demand for W&B logging")
+        except Exception as _e:
+            print("wandb setup skipped:", _e)
+        # NB: the Hopper fla guard lives in engine.worker._drop_fla_on_hopper (runs in the worker
+        # process after all installs, before any model import) — not here, where a later
+        # install could pull fla back in. The bootstrap just fetches code and runs the worker.
+
+        extra_pip = payload.get("extra_pip") or []
+        if extra_pip:
+            # check=True: a deterministic dependency failure (GRPO / Prime Hub
+            # / verifiers extras) must stop NOW with an actionable error, not proceed to
+            # a later import crash while the paid instance runs (matches the RunPod path).
+            subprocess.run([sys.executable, "-m", "pip", "install", *extra_pip], check=True)
+        _wenv = payload.get("env") or {}
+        # NB: fla is dropped on Hopper (sm90) automatically by engine.worker._drop_fla_on_hopper at
+        # worker startup (fla's GDN backward is miscomputed on sm90, #640) — no bootstrap uninstall
+        # or env toggle. fla only ever runs on the consumer archs where its Triton kernel is correct.
+        # Install the run's verifiers environment(s) from the Prime Hub via the
+        # authenticated `prime` CLI (mirrors runpod/train.py:_train_body). The public pip
+        # index does not serve PRIVATE env wheels; `prime env install` pulls/builds/installs
+        # public + private alike, authenticated by PRIME_API_KEY forwarded in the payload env.
+        hub_env_ids = payload.get("hub_env_ids") or []
+        if hub_env_ids:
+            worker_env = {k: str(v) for k, v in (payload.get("env") or {}).items()}
+            prime_key = worker_env.get("PRIME_API_KEY") or os.environ.get("PRIME_API_KEY")
+            if not prime_key:
+                raise RuntimeError(
+                    "PRIME_API_KEY is required to install the Prime Hub environment on the worker"
+                )
+            # Only install `prime` when it isn't already present (it's often baked into the
+            # instance image) — an unconditional install adds latency and a per-run PyPI
+            # failure point every run.
+            if shutil.which("prime") is None:
+                subprocess.run([sys.executable, "-m", "pip", "install", "prime"], check=True)
+            # Resolve the prime binary (located path if present, else the bare name) so the env
+            # install runs through the actually-installed CLI.
+            prime_bin = shutil.which("prime") or "prime"
+            install_env = {
+                **os.environ,
+                "PRIME_API_KEY": prime_key,
+                "PRIME_DISABLE_VERSION_CHECK": "1",
+                "PIP_BREAK_SYSTEM_PACKAGES": "1",
+            }
+            # --with pip: install the env into THIS python via pip, not prime's isolated uv env
+            # (the default), so the trainer can import the env module at load_environment.
+            for env_id in hub_env_ids:
+                subprocess.run(
+                    [prime_bin, "env", "install", env_id, "--with", "pip"],
+                    check=True,
+                    env=install_env,
+                )
+        fetch_code(payload)
+        env = build_worker_env(payload)
+        deadline = time.time() + float(payload.get("max_wall_s") or 24 * 3600)
+        phase = payload["phase"]
+        # A warm/retried Vast instance can carry a previous attempt's metrics file; a
+        # stale one would let a crashed train phase report the previous run's metrics.
+        # Clear before training (mirrors the RunPod Flash handler in runpod/train.py).
+        for stale in ("/tmp/train_meta.json", "/tmp/metrics.json"):
+            with contextlib.suppress(FileNotFoundError):
+                os.remove(stale)
+        # Train. Nonzero rc tolerated — RL's colocated vLLM can segfault at interpreter
+        # exit AFTER the adapter + metrics.json + DONE are saved. The train phase writes
+        # metrics.json + DONE itself (or restores them from an earlier attempt's DONE).
+        run_mode(payload, env, phase, deadline)
+        if not os.path.exists("/tmp/metrics.json"):
+            raise RuntimeError(
+                f"train phase '{phase}' produced no /tmp/metrics.json (it crashed before "
+                f"finishing); see error_{phase}.txt and console_{phase}.txt in the HF "
+                f"dataset repo"
+            )
+        ok = True
+    except Exception as exc:
+        # Record genuine failures in the attempt marker (written in `finally`). Don't catch
+        # BaseException — KeyboardInterrupt/SystemExit must propagate after the marker write
+        # rather than be swallowed into a `return 1`.
+        error = f"{type(exc).__name__}: {exc}"
+        print(f"bootstrap failed: {error}", flush=True)
+    finally:
+        write_attempt_marker(payload, ok, error)
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

code/autoslm/providers/vast/api.py

@@ -0,0 +1,221 @@
+"""Thin Vast.ai REST client (no SDK state): offer search + instance lifecycle.
+
+Mirrors ``providers/runpod/api.py``: stdlib urllib only, hardened retries, and nothing
+persisted locally — a fresh process can list/destroy any instance using only the
+persisted ids + VAST_API_KEY. Only ``verified`` offers are searched (the datacenter-only
+filter is NOT applied, so verified community/marketplace hosts are included too); callers
+re-check hosting_type + verification + the reliability floor client-side.
+"""
+
+from __future__ import annotations
+
+import time
+import urllib.error
+import urllib.request
+from typing import Any
+
+from autoslm.providers._http import RestClient
+
+VAST_BASE = "https://console.vast.ai/api"
+
+
+class VastApiError(RuntimeError):
+    pass
+
+
+# Shared urllib client (path form: callers pass paths joined onto VAST_BASE).
+# Env-only by design, like RUNPOD_API_KEY: the operator sets VAST_API_KEY on the
+# control-plane host; it is never written to config files or shipped to workers.
+_CLIENT = RestClient(
+    env_var="VAST_API_KEY",
+    error_cls=VastApiError,
+    base_url=VAST_BASE,
+    missing_key_message=("VAST_API_KEY not configured on the control-plane host"),
+)
+
+
+def _api_key() -> str:
+    return _CLIENT.api_key()
+
+
+def _request(path: str, method: str = "GET", body: dict | None = None, timeout: float = 30.0):
+    return _CLIENT.request(path, method=method, body=body, timeout=timeout)
+
+
+def request_with_retries(
+    path: str,
+    method: str = "GET",
+    body: dict | None = None,
+    retries: int = 4,
+    base_delay: float = 2.0,
+) -> Any:
+    """REST call hardened against transient network/5xx blips (jittered backoff)."""
+    return _CLIENT.request_with_retries(
+        path, method=method, body=body, retries=retries, base_delay=base_delay
+    )
+
+
+# ---------------------------------------------------------------------------
+# Offer search
+# ---------------------------------------------------------------------------
+def search_offers(
+    min_vram_mb: int,
+    *,
+    min_disk_gb: float = 0,
+    min_reliability: float = 0.95,
+    num_gpus: int = 1,
+    limit: int = 64,
+    extra_q: dict | None = None,
+) -> list[dict]:
+    """Rentable single-GPU offers from verified hosts, cheapest first. We drop the server-side
+    datacenter-only filter so verified COMMUNITY/marketplace hosts are returned alongside
+    datacenter ones (usable_offers still re-checks hosting_type + verification + the reliability
+    floor, so quality is enforced downstream).
+
+    ``datacenter`` here is Vast's hosting-type filter (professional datacenters vs
+    consumer/hobbyist machines); results additionally carry ``hosting_type`` which
+    callers must re-check (``usable_offers``) — never trust one filter layer alone.
+    """
+    # We intentionally do NOT apply Vast's server-side datacenter-only filter: verified
+    # COMMUNITY/marketplace hosts are included too (scarce classes often have no verified-datacenter
+    # supply), and usable_offers re-checks hosting_type + verification + the reliability floor.
+    # Rent an instance with EXACTLY ``num_gpus`` GPUs (default 1). Exact-match (not >=) so a
+    # 2-GPU disaggregated run pays for a 2-GPU machine, not an 8-GPU one (dph_total is per-instance).
+    q: dict[str, Any] = {
+        "verified": {"eq": True},
+        "rentable": {"eq": True},
+        "num_gpus": {"eq": int(num_gpus)},
+        "gpu_ram": {"gte": int(min_vram_mb)},
+        "reliability2": {"gte": float(min_reliability)},
+        "type": "ask",
+        "order": [["dph_total", "asc"]],
+        "limit": int(limit),
+    }
+    if min_disk_gb:
+        q["disk_space"] = {"gte": float(min_disk_gb)}
+    if extra_q:
+        q.update(extra_q)
+    out = request_with_retries("/v0/search/asks/", method="PUT", body={"q": q})
+    offers = out.get("offers") if isinstance(out, dict) else None
+    return offers if isinstance(offers, list) else []
+
+
+# ---------------------------------------------------------------------------
+# Instances
+# ---------------------------------------------------------------------------
+def create_instance(
+    offer_id: int,
+    *,
+    image: str,
+    disk_gb: float,
+    env: dict[str, str],
+    onstart: str,
+    label: str,
+    runtype: str = "args",
+) -> int:
+    """Rent an offer -> instance id. Raises VastApiError on rejection (offer taken).
+
+    Default ``args`` runtype (verified live): the script IS the container command
+    (``bash -c``), so the job needs no SSH key on the account, the container's
+    lifecycle is the job's lifecycle, and the Vast-injected CONTAINER_API_KEY /
+    CONTAINER_ID env vars are available for the self-destroy backstop. ``ssh``
+    runtype requires an SSH key attached to the Vast account.
+    """
+    body = {
+        "client_id": "me",
+        "image": image,
+        "disk": float(disk_gb),
+        "env": dict(env),
+        "label": label,
+        "runtype": runtype,
+    }
+    # The worker image is PUBLIC, so Vast pulls it with no docker-login (no image_login / pull
+    # token is ever shipped to the untrusted host).
+    if runtype == "args":
+        body["args"] = ["bash", "-c", onstart]
+    else:
+        body["onstart"] = onstart
+    # NON-IDEMPOTENT: ``PUT /asks/{id}`` rents a NEW instance every time it succeeds.
+    # A blind retry on a timeout where Vast actually accepted the first request would
+    # double-provision (two billed instances, one invisible to our handle). So this
+    # call is NOT retried — a transient failure surfaces to deploy_and_submit, which
+    # walks to the next offer, and to the orchestrator, which consumes a run retry; a
+    # duplicate paid instance is the worse failure. (Idempotent calls — search,
+    # detail, destroy — keep their retries.)
+    out = request_with_retries(f"/v0/asks/{int(offer_id)}/", method="PUT", body=body, retries=0)
+    if not isinstance(out, dict) or not out.get("success"):
+        raise VastApiError(f"create_instance({offer_id}) rejected: {out}")
+    instance_id = out.get("new_contract")
+    if not instance_id:
+        raise VastApiError(f"create_instance({offer_id}): no instance id in response: {out}")
+    return int(instance_id)
+
+
+def get_instance(instance_id: int) -> dict | None:
+    """Instance detail dict, or None once it no longer exists (destroyed).
+
+    The v0 detail route answers 200 with ``{"instances": null}`` for unknown ids
+    (verified live) — that is the "gone" signal, not a 404.
+    """
+    try:
+        out = request_with_retries(f"/v0/instances/{int(instance_id)}/")
+    except VastApiError as e:
+        if "404" in str(e):
+            return None
+        raise
+    if isinstance(out, dict):
+        if "instances" in out:
+            inst = out["instances"]
+            return inst if isinstance(inst, dict) else None
+        return out
+    return None
+
+
+def list_instances() -> list[dict]:
+    # The v0 list route is deprecated (410 "use /api/v1/instances/", verified live);
+    # detail/destroy remain on v0.
+    out = request_with_retries("/v1/instances/")
+    inst = out.get("instances") if isinstance(out, dict) else None
+    return inst if isinstance(inst, list) else []
+
+
+def instance_logs(instance_id: int, tail: int = 400, wait_s: float = 20.0) -> str | None:
+    """Container log tail via the logs API (request -> poll the result URL).
+
+    The only place early-bootstrap failures (pip/env errors before the worker can
+    reach HF) are visible. Best-effort: returns None when logs are unavailable
+    (e.g. the instance is already destroyed); never raises.
+    """
+    try:
+        out = request_with_retries(
+            f"/v0/instances/request_logs/{int(instance_id)}/",
+            method="PUT",
+            body={"tail": str(int(tail))},
+            retries=1,
+        )
+        url = out.get("result_url") if isinstance(out, dict) else None
+        if not url:
+            return None
+        deadline = time.time() + wait_s
+        while time.time() < deadline:
+            try:
+                with urllib.request.urlopen(url, timeout=15) as resp:
+                    body = resp.read().decode(errors="replace")
+                if body.strip():
+                    return body
+            except urllib.error.HTTPError as e:
+                if e.code != 404:  # 404 = not materialized yet
+                    return None
+            time.sleep(2.0)
+    except Exception:
+        return None
+    return None
+
+
+def destroy_instance(instance_id: int) -> bool:
+    """Destroy (and stop billing for) an instance. Best-effort: never raises."""
+    try:
+        request_with_retries(f"/v0/instances/{int(instance_id)}/", method="DELETE", retries=2)
+        return True
+    except Exception:
+        return False

code/autoslm/providers/vast/auth.py

@@ -0,0 +1,25 @@
+"""Vast.ai credential handling (operator-side), mirroring the RunPod auth module.
+
+The Vast REST client authenticates via the ``VAST_API_KEY`` environment variable, set
+by the **operator** on the control-plane host. Env-only by
+design, exactly like ``RUNPOD_API_KEY``: it is never written to config files or shipped
+to workers (the instance self-destroy backstop uses the Vast-injected, instance-scoped
+``CONTAINER_API_KEY`` instead).
+"""
+
+from __future__ import annotations
+
+import os
+
+
+def load_api_key() -> str | None:
+    """Vast API key from the environment (operator configuration)."""
+    return os.environ.get("VAST_API_KEY") or None
+
+
+def ensure_auth() -> str:
+    """Ensure ``VAST_API_KEY`` is set; raise if unavailable."""
+    key = load_api_key()
+    if not key:
+        raise RuntimeError("no Vast API key found; set VAST_API_KEY on the control-plane host")
+    return key

code/autoslm/providers/vast/gpus.py

@@ -0,0 +1,21 @@
+"""Vast's GPU classes + the offer->class mapping.
+
+The class table is provider-agnostic and lives in ``providers/base.py``. This module
+carves out Vast's rows (``gpu_classes()`` == every class with a ``vast_name``,
+including the Vast-only classes L40S / RTX Pro 4000 / A100 SXM 40GB). The offer->class
+mapping (``vast_gpu_for_offer``) lives in ``providers/base.py`` and the job path imports
+it from there directly.
+"""
+
+from __future__ import annotations
+
+from autoslm.providers.base import GpuClass
+
+__all__ = ["gpu_classes"]
+
+
+def gpu_classes() -> list[GpuClass]:
+    """The GPU classes Vast can provision (those with a ``vast_name``)."""
+    from autoslm.providers.base import GPU_INFO
+
+    return [g for g in GPU_INFO.values() if g.vast_name]

code/autoslm/providers/vast/jobs.py

@@ -0,0 +1,761 @@
+"""Vast.ai run lifecycle: verified offers -> instance -> HF-artifact poll.
+
+The Vast equivalent of ``providers/runpod/jobs.py``. Vast has no serverless queue:
+we rent a single-GPU instance from a VERIFIED offer (datacenter or community), ship a self-contained
+bootstrap (the private ``_bootstrap`` module) through the onstart script, and detect
+completion purely via the worker's HF artifacts (DONE/metrics.json/heartbeat.json) +
+the instance's status — no inbound network to the box is ever needed.
+
+The instance bootstrap is an INTERNAL detail of this module (``build_onstart`` reads
+``_bootstrap.py``), so the public per-provider module set stays identical to RunPod's.
+
+Cost-safety invariant: a rented instance is ALWAYS destroyed — the runner's
+``finally``, the onstart's self-destroy backstop, the cancel path, and
+``sweep_orphans`` (server startup / post-run) each independently guarantee it.
+"""
+
+from __future__ import annotations
+
+import base64
+import contextlib
+import json
+import shlex
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from autoslm._logging import get_logger
+from autoslm.providers._poll import PollErrorTracker, make_say, surface_heartbeat
+from autoslm.providers.base import GPU_INFO, PollResult, min_cuda_modern, vast_gpu_for_offer
+from autoslm.providers.runpod.jobs import make_hf_heartbeat_reader, make_hf_text_reader
+from autoslm.providers.vast import api as vast_api
+
+logger = get_logger(__name__)
+
+# Offer-quality floors (beyond verified+datacenter, which are non-negotiable). reliability2 is
+# Vast's host-uptime/health score: 0.95 let ~1-in-20 long runs die mid-train ("worker terminated
+# without a DONE sentinel" when the host went down); 0.995 (~1-in-200) keeps supply usable (the
+# >=0.995 datacenter pool measured 67 offers) while nearly eliminating mid-run host deaths. These
+# are fixed correctness floors, not operator-tunable.
+RELIABILITY_FLOOR = 0.995
+MIN_INET_MBPS = 200.0
+# How long an instance may sit in a non-running state (image pull) before we give up.
+LOAD_TIMEOUT_S = 900.0
+# Boards under-report VRAM vs the class nominal (measured live: L4 23034 MB / 24 GB,
+# A40 46068 MB / 48 GB = 0.938 of nominal); the server-side gpu_ram filter gets this
+# slack, the class gate stays exact (vast_gpu_for_offer).
+_SEARCH_VRAM_SLACK = 0.92
+
+# Minimum disk Vast instances are provisioned with (the bootstrap + worker stack +
+# weights need headroom regardless of the spec's request). The offer search MUST use
+# this same floor so offers with <60 GB disk don't pass the search and then get
+# rejected at create time (``create_instance`` enforces the same max).
+MIN_DISK_GB = 60.0
+
+
+def _effective_disk_gb(spec) -> float:
+    """The disk size an instance is actually provisioned with (the create-time floor).
+
+    Both the offer search and ``create_instance`` must agree on this, or offers with a
+    disk between ``spec.gpu.disk_gb`` and the floor pass the search then fail to rent.
+    """
+    return max(float(spec.gpu.disk_gb), MIN_DISK_GB)
+
+
+@dataclass(frozen=True)
+class VastOffer:
+    """A normalized, fully-vetted offer (passed every ``usable_offers`` filter)."""
+
+    offer_id: int
+    machine_id: int
+    gpu: str  # canonical class name (GPU_INFO key)
+    vram_gb: int
+    dph_total: float
+    cuda_max_good: float
+    disk_space: float
+    reliability: float
+    inet_down: float
+    geolocation: str
+    num_gpus: int = 1  # GPUs on this instance (for multi-GPU disaggregated runs + cost reporting)
+
+
+def usable_offers(
+    min_vram_gb: int,
+    disk_gb: float,
+    exclude_machine_ids: set[int] | frozenset[int] = frozenset(),
+    num_gpus: int = 1,
+) -> list[VastOffer]:
+    """Verified offers (datacenter or community) able to run the job, cheapest first.
+
+    ``num_gpus`` (default 1) rents an instance with exactly that many GPUs — the disaggregated
+    async GRPO path needs a multi-GPU node ([gpu] count). ``min_vram_gb`` is the PER-GPU floor
+    (each card holds a trainer or rollout shard), unchanged by the count.
+
+    Server-side filters do the heavy lifting; everything load-bearing is re-checked
+    client-side (belt and suspenders — the result rows carry the proof fields).
+    """
+    rows = vast_api.search_offers(
+        int(min_vram_gb * 1024 * _SEARCH_VRAM_SLACK),
+        min_disk_gb=disk_gb,
+        min_reliability=RELIABILITY_FLOOR,
+        num_gpus=num_gpus,
+    )
+    # Always include Vast-VERIFIED marketplace hosts (hosting_type 0) alongside datacenter-only
+    # (hosting_type==1): they are still verified and reliability-floored (RELIABILITY_FLOOR above),
+    # just not datacenter-tier. Scarce classes are often only offered by community hosts while the
+    # RunPod equivalent is capacity-throttled, so as long as the reliability floor is met we take them.
+    allow_community = True
+    out: list[VastOffer] = []
+    for r in rows:
+        gpu = vast_gpu_for_offer(str(r.get("gpu_name") or ""), float(r.get("gpu_ram") or 0))
+        if gpu is None:  # not a managed class (Ampere+ floor)
+            continue
+        info = GPU_INFO[gpu]
+        dph = float(r.get("dph_total") or 0)
+        cuda = float(r.get("cuda_max_good") or 0)
+        # Host tier: accept verified datacenter (hosting_type==1) AND verified community
+        # (hosting_type==0) hosts — community is always allowed, still gated by the reliability
+        # floor + verification below; any other hosting_type is rejected.
+        _bad_host = r.get("hosting_type") != 1 and not (
+            allow_community and r.get("hosting_type") == 0
+        )
+        # MULTI-GPU: require a WHOLE-machine offer with an EXPLICIT gpu_frac ~= 1.0. A fractional
+        # multi-GPU offer (e.g. 2 of an 8-GPU box, gpu_frac=0.25/0.5) rents 2 GPUs to the INSTANCE
+        # but the CONTAINER gets only 1 (Vast sets NVIDIA_VISIBLE_DEVICES=void and mounts the
+        # fraction's devices — verified: nvidia-smi -L=1, env void). A MISSING gpu_frac is treated
+        # as NOT-whole-machine here (a $0.54 missing-frac offer also yielded a 1-GPU container), so
+        # require the field present and >=0.99 — whole-machine offers carry gpu_frac=1.0 explicitly.
+        # float() guarded: a present-but-non-numeric gpu_frac (e.g. "" / null-ish string) would
+        # raise ValueError and abort the WHOLE offer search; treat unparseable as not-whole-machine
+        # (rejected), consistent with requiring an explicit numeric >=0.99.
+        try:
+            _gf_val = float(r.get("gpu_frac"))
+        except (TypeError, ValueError):
+            _gf_val = 0.0
+        _frac_ok = num_gpus <= 1 or _gf_val >= 0.99
+        if (
+            _bad_host
+            or not _frac_ok
+            or r.get("verification") != "verified"
+            # Exact class gate: guard against a board whose canonical class nominal VRAM
+            # is below the request (e.g. asking for 48 GB but the mapping landed on a
+            # 24 GB class) — the server-side gpu_ram filter only carries slack.
+            or info.vram_gb < min_vram_gb
+            or float(r.get("reliability2") or 0) < RELIABILITY_FLOOR
+            or float(r.get("disk_space") or 0) < float(disk_gb)
+            or float(r.get("inet_down") or 0) < MIN_INET_MBPS
+            or cuda < float(min_cuda_modern(gpu))  # Blackwell needs CUDA-13 drivers
+            or dph <= 0
+            or int(r.get("machine_id") or 0) in exclude_machine_ids
+        ):
+            continue
+        out.append(
+            VastOffer(
+                offer_id=int(r["id"]),
+                machine_id=int(r.get("machine_id") or 0),
+                gpu=gpu,
+                vram_gb=info.vram_gb,
+                dph_total=dph,
+                cuda_max_good=cuda,
+                disk_space=float(r.get("disk_space") or 0),
+                reliability=float(r.get("reliability2") or 0),
+                inet_down=float(r.get("inet_down") or 0),
+                geolocation=str(r.get("geolocation") or ""),
+                num_gpus=int(r.get("num_gpus") or num_gpus),
+            )
+        )
+    return sorted(out, key=lambda o: (o.dph_total, o.vram_gb))
+
+
+def vast_image() -> str:
+    """Docker image for the worker: the prebuilt, PUBLIC WORKER_IMAGE (full training stack baked
+    in). Used for every GPU class — the Blackwell driver floor lives in the ``cuda_max_good`` offer
+    filter, not the image. There is no generic fallback image; the worker image is always used."""
+    from autoslm.providers.runpod.train import WORKER_IMAGE
+
+    return WORKER_IMAGE
+
+
+@dataclass
+class VastJobHandle:
+    """Persisted in RunStatus.remote so any process can reattach/cancel (cf. JobHandle)."""
+
+    instance_id: int
+    offer_id: int
+    machine_id: int
+    label: str
+    gpu: str
+    hourly_usd: float
+    attempt: int
+    started_ts: float
+
+    def to_dict(self) -> dict:
+        return {
+            "provider": "vast",
+            "instance_id": self.instance_id,
+            "offer_id": self.offer_id,
+            "machine_id": self.machine_id,
+            "label": self.label,
+            "gpu": self.gpu,
+            "hourly_usd": self.hourly_usd,
+            "attempt": self.attempt,
+            "started_ts": self.started_ts,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> VastJobHandle:
+        return cls(
+            instance_id=int(d["instance_id"]),
+            offer_id=int(d.get("offer_id") or 0),
+            machine_id=int(d.get("machine_id") or 0),
+            label=str(d.get("label") or ""),
+            gpu=str(d.get("gpu") or ""),
+            hourly_usd=float(d.get("hourly_usd") or 0),
+            attempt=int(d.get("attempt") or 0),
+            started_ts=float(d.get("started_ts") or 0),
+        )
+
+
+def run_label_prefix(run_id: str) -> str:
+    """The prefix EVERY instance label for ``run_id`` starts with.
+
+    ``instance_label`` forces the ``autoslm-`` prefix onto run ids that lack it, so the
+    orphan-sweep allowlist must apply the SAME transform: a raw run id (e.g. a
+    "fail-fast" test id) would otherwise never match its own ``autoslm-…`` labels and a
+    live run's instance could be swept (or fail to be protected)."""
+    return f"autoslm-{run_id}" if not run_id.startswith("autoslm-") else run_id
+
+
+def instance_label(run_id: str, seed: int, attempt: int) -> str:
+    """Instance label: run-derived so ``sweep_orphans`` can tell ours from anything
+    else on the account. Platform run ids already start with ``autoslm-``; anything else
+    (direct-API callers, tests) gets the prefix forced — an instance we rented must NEVER
+    be invisible to the orphan sweep."""
+    return f"{run_label_prefix(run_id)}-s{seed}-a{attempt}"
+
+
+def build_payload(spec, seed: int, attempt: int) -> dict:
+    """The bootstrap's input — field-compatible with _train_body's, plus the bits the
+    instance can't infer (HF prefix for markers, wall cap, attempt)."""
+    from autoslm.envs.registry import worker_hub_env_ids, worker_pip_for_env
+    from autoslm.providers.runpod.train import build_worker_env
+
+    return {
+        "hf_repo": spec.train.hf_repo,
+        "job_spec_json": spec.to_json(),
+        "phase": spec.phase,
+        "seed": int(seed),
+        "env": build_worker_env(spec, seed),
+        "extra_pip": list(spec.environment.pip) or worker_pip_for_env(spec.environment.id),
+        "hub_env_ids": worker_hub_env_ids(spec.environment.id, spec.environment.params),
+        "hf_prefix": f"{spec.phase}/{spec.run_id}/seed{seed}",
+        "max_wall_s": max(60, int(spec.gpu.max_wall_seconds)),
+        "attempt": int(attempt),
+    }
+
+
+def build_onstart(payload: dict, install_deps: bool = True) -> str:
+    """The instance's onstart script: payload + bootstrap shipped as quoted heredocs.
+
+    Everything dynamic travels base64-encoded inside the script — never interpolated
+    into shell syntax and never through Vast's env plumbing — so the job-spec JSON
+    (quotes, spaces, anything) survives byte-exact. Secrets-wise the script carries
+    the same content as the worker env on RunPod (HF token; never provider keys).
+
+    The bootstrap source is the private ``_bootstrap.py`` sibling — an internal detail
+    of this provider, not a public module.
+    """
+    from autoslm.providers.runpod.train import resolve_worker_deps
+
+    payload_b64 = base64.encodebytes(json.dumps(payload).encode()).decode()
+    bootstrap_src = (Path(__file__).parent / "_bootstrap.py").read_text()
+    if install_deps:
+        deps = " ".join(shlex.quote(d) for d in resolve_worker_deps())
+        # Vast cold-start is dominated by this dep install (torch/vllm/transformers cu128 stack) on
+        # fresh hosts — RunPod caches it as a Flash artifact, but Vast reinstalls per host, so use
+        # `uv pip` (validated in the worker image: resolves + installs the full pinned cu128 stack
+        # in ~12s, ~10x faster than pip). --break-system-packages: PYBIN is the image's
+        # externally-managed system python (newer pytorch images dropped /opt/conda); uv refuses it
+        # without this flag (and ignores pip's PIP_BREAK_SYSTEM_PACKAGES), which is what silently
+        # broke the earlier uv attempt. The flag is a no-op on a conda/venv python, so it's safe
+        # across image variants.
+        pip_line = (
+            '"$PYBIN" -m pip install --no-cache-dir uv '
+            f'&& "$PYBIN" -m uv pip install --python "$PYBIN" --break-system-packages --no-cache {deps}'
+        )
+    else:
+        pip_line = ": # deps baked into the image (WORKER_IMAGE)"
+    # Verified live: Vast's args-mode wrapper resets PATH, so `python3` resolves to
+    # the OS python (Ubuntu 24.04 = PEP 668 externally-managed -> pip refuses), not
+    # the image's conda env. Prefer the conda python when present (torch baked in),
+    # and let pip install into whichever interpreter won.
+    return f"""#!/bin/bash
+# AutoSLM vast worker (generated by autoslm.providers.vast.jobs.build_onstart)
+set -x
+export PIP_BREAK_SYSTEM_PACKAGES=1
+PYBIN=/opt/conda/bin/python; [ -x "$PYBIN" ] || PYBIN=/usr/local/bin/python; [ -x "$PYBIN" ] || PYBIN=$(command -v python3)
+mkdir -p /root/autoslm
+cat > /root/autoslm/payload.b64 <<'AUTOSLM_PAYLOAD_EOF'
+{payload_b64}AUTOSLM_PAYLOAD_EOF
+base64 -d /root/autoslm/payload.b64 > /root/autoslm/payload.json
+cat > /root/autoslm/bootstrap.py <<'AUTOSLM_BOOTSTRAP_EOF'
+{bootstrap_src}AUTOSLM_BOOTSTRAP_EOF
+# A base worker-stack install failure must STOP the script: continuing into
+# bootstrap.py with a partially installed env turns a deterministic dependency
+# failure into a later import/model crash (or a missing HF marker if
+# huggingface_hub never installed). Hold the box first so the control plane can
+# pull the log tail (mirrors the bootstrap-failure path below and the extra-pip
+# check=True path). The no-deps branch (":") always succeeds, so this is a no-op there.
+{pip_line} || {{ echo "AUTOSLM: base worker dependency install failed" >&2; sleep 600; exit 1; }}
+"$PYBIN" /root/autoslm/bootstrap.py
+AUTOSLM_RC=$?
+# On failure, hold the box for 10 min so the control plane can pull the container
+# log tail (the only home of early-bootstrap errors); it destroys us much sooner
+# when alive. Success self-destroys immediately.
+[ "$AUTOSLM_RC" -ne 0 ] && sleep 600
+# Self-destroy backstop (the control plane's destroy is primary). CONTAINER_API_KEY
+# is the Vast-injected instance-scoped key — the operator key never ships here.
+# python, not curl: the worker image is not guaranteed to carry curl.
+"$PYBIN" - <<'AUTOSLM_DESTROY_EOF'
+import os, urllib.request
+iid, key = os.environ.get("CONTAINER_ID"), os.environ.get("CONTAINER_API_KEY")
+if iid and key:
+    req = urllib.request.Request(
+        f"https://console.vast.ai/api/v0/instances/{{iid}}/",
+        method="DELETE",
+        headers={{"Authorization": f"Bearer {{key}}"}},
+    )
+    try:
+        urllib.request.urlopen(req, timeout=30)
+    except Exception as exc:
+        print("self-destroy warn:", exc)
+AUTOSLM_DESTROY_EOF
+exit $AUTOSLM_RC
+"""
+
+
+def deploy_and_submit(
+    spec,
+    seed: int,
+    offers: list[VastOffer],
+    attempt: int = 0,
+    log=None,
+    exclude_machine_ids: set[int] | frozenset[int] = frozenset(),
+) -> VastJobHandle:
+    """Rent the cheapest offer that will actually take the job; walk on rejection.
+
+    Offers are a live market — between search and rent the cheapest one is often
+    gone. We walk up to 5 ranked offers, then refresh the search once.
+
+    ``exclude_machine_ids`` is the run's blacklist (machines that stalled/failed this
+    run earlier). The refresh re-search MUST keep them excluded — otherwise a sick
+    machine the orchestrator just blacklisted gets re-selected from the fresh market.
+    """
+
+    def say(msg: str):
+        if log is not None:
+            print(f"[{time.strftime('%H:%M:%S')}] {msg}", file=log, flush=True)
+
+    if not offers:
+        raise vast_api.VastApiError("no usable vast offers (verified datacenter pool empty)")
+    payload = build_payload(spec, seed, attempt)
+    label = instance_label(spec.run_id, seed, attempt)
+    from autoslm.providers.runpod.train import WORKER_IMAGE
+
+    install_deps = not WORKER_IMAGE
+    tried: list[VastOffer] = []
+    candidates = list(offers[:5])
+    refreshed = False
+    last_err: Exception | None = None
+    while candidates:
+        offer = candidates.pop(0)
+        tried.append(offer)
+        onstart = build_onstart(payload, install_deps=install_deps)
+        try:
+            instance_id = vast_api.create_instance(
+                offer.offer_id,
+                image=vast_image(),
+                disk_gb=_effective_disk_gb(spec),
+                # Expose ALL rented GPUs to the container. The worker image is pytorch/pytorch
+                # (not nvidia/cuda) and the NVIDIA container runtime only surfaces the GPUs named
+                # in NVIDIA_VISIBLE_DEVICES — without this a multi-GPU offer's container can come up
+                # with just 1 GPU (observed: a num_gpus=2 5090 offer exposed 1 GPU, breaking the
+                # disaggregated split). "all" = all GPUs in the container's cgroup, i.e. exactly the
+                # rented ones (not other tenants'); harmless for single-GPU runs.
+                env={"NVIDIA_VISIBLE_DEVICES": "all"},
+                onstart=onstart,
+                label=label,
+                runtype="args",
+            )
+        except vast_api.VastApiError as e:
+            last_err = e
+            say(f"offer {offer.offer_id} ({offer.gpu} ${offer.dph_total:.2f}/hr) rejected: {e}")
+            if not candidates and not refreshed:
+                refreshed = True
+                # Exclude both the machines we just tried this attempt AND the run's
+                # standing blacklist (machines that stalled/failed earlier attempts) —
+                # otherwise the fresh search can re-select a sick machine the
+                # orchestrator deliberately excluded.
+                taken = {o.machine_id for o in tried} | set(exclude_machine_ids)
+                # Stay within the allocator-approved class pool: the original `offers`
+                # are already filtered to the allocated/pinned + validated classes, so
+                # the refresh must not widen to any usable offer (which could rent a
+                # different or unvalidated GPU than the run spec assumes).
+                allowed = {o.gpu for o in offers}
+                candidates = [
+                    o
+                    for o in usable_offers(
+                        min(o.vram_gb for o in offers),
+                        _effective_disk_gb(spec),
+                        exclude_machine_ids=taken,
+                        num_gpus=int(getattr(spec.gpu, "count", 1)),
+                    )
+                    if o.gpu in allowed
+                ][:5]
+            continue
+        say(
+            f"rented vast instance {instance_id}: {offer.gpu} ${offer.dph_total:.2f}/hr "
+            f"(offer {offer.offer_id}, {offer.geolocation}, reliability "
+            f"{offer.reliability:.3f}) attempt={attempt} seed={seed}"
+        )
+        return VastJobHandle(
+            instance_id=instance_id,
+            offer_id=offer.offer_id,
+            machine_id=offer.machine_id,
+            label=label,
+            gpu=offer.gpu,
+            hourly_usd=offer.dph_total,
+            attempt=attempt,
+            started_ts=time.time(),
+        )
+    raise vast_api.VastApiError(f"all {len(tried)} vast offers rejected the job: {last_err}")
+
+
+# Rate-limited reader for one HF artifact's text content (None until it exists). Shared
+# with runpod's poller via make_hf_text_reader; kept under this module-local name because
+# tests monkeypatch ``vast.jobs._make_hf_file_reader`` and the poll/failure paths below
+# resolve it as a module global (so a monkeypatch still takes effect).
+_make_hf_file_reader = make_hf_text_reader
+
+
+def _failure_detail(
+    hf_repo: str, prefix: str, phase: str, marker: dict | None, instance_id: int | None = None
+) -> str:
+    """Best root-cause detail we can assemble from the HF artifacts."""
+    parts = []
+    if marker and marker.get("error"):
+        parts.append(str(marker["error"]))
+    content = _make_hf_file_reader(hf_repo, f"{prefix}/error_{phase}.txt")(force=True)
+    if content:
+        parts.append(f"--- error_{phase}.txt ---\n{content[-2000:]}")
+    if instance_id:
+        # Early-bootstrap failures (pip/env errors before the worker can reach HF)
+        # only ever appear on the container console.
+        logs = vast_api.instance_logs(int(instance_id))
+        if logs:
+            parts.append(f"--- instance log tail ---\n{logs[-3000:]}")
+    return "\n".join(parts) or "vast worker terminated without a DONE sentinel"
+
+
+# Vast instance states that mean "the container is gone / will not progress".
+_DEAD_STATES = {"exited", "stopped", "offline", "deleted"}
+
+
+def poll_vast_job(
+    handle: VastJobHandle,
+    spec,
+    seed: int,
+    log=None,
+    interval_s: float = 15.0,
+    heartbeat_reader=None,
+    stall_after_s: float = 1500.0,
+    deadline_s: float | None = None,
+) -> PollResult:
+    """Poll instance status + HF artifacts to a terminal state (cf. jobs.poll_job).
+
+    COMPLETED  fresh DONE sentinel on HF -> metrics.json (cost stamped from the
+               offer's real $/hr).
+    FAILED     attempt marker with ok=false, or instance dead without DONE.
+    STALLED    never left loading within LOAD_TIMEOUT_S, heartbeat frozen for
+               stall_after_s, or the client-side deadline passed.
+    """
+
+    say = make_say(log)
+
+    hf_repo = spec.train.hf_repo
+    prefix = f"{spec.phase}/{spec.run_id}/seed{seed}"
+    done_reader = _make_hf_file_reader(hf_repo, f"{prefix}/DONE")
+    marker_reader = _make_hf_file_reader(
+        hf_repo, f"{prefix}/vast_attempt{handle.attempt}.json", min_interval_s=60.0
+    )
+    metrics_reader = _make_hf_file_reader(hf_repo, f"{prefix}/metrics.json")
+
+    def finish_ok(done_content: str | None = None) -> PollResult:
+        raw = metrics_reader(force=True)
+        if raw is None:
+            return PollResult(False, failure="job_failed", detail="DONE without metrics.json")
+        metrics = json.loads(raw)
+        # Prefer the worker's DONE timestamp when present and sane; fall back to now.
+        # On delayed recovery the control plane may call this hours after the instance
+        # wrote DONE and self-destroyed, so billing to now would over-bill by the
+        # downtime — accepted because a missing/garbled DONE timestamp is rare. DONE
+        # carries the worker's time.time().
+        end_ts = time.time()
+        if done_content:
+            try:
+                done_ts = float(done_content.strip())
+                if handle.started_ts <= done_ts <= end_ts:
+                    end_ts = done_ts
+            except ValueError:
+                # Malformed DONE timestamp: keep end_ts = now rather than trusting garbage.
+                pass
+        wall_h = (end_ts - handle.started_ts) / 3600.0
+        metrics["cost_usd"] = round(wall_h * handle.hourly_usd, 6)
+        notes = metrics.get("notes") if isinstance(metrics.get("notes"), dict) else {}
+        notes.update(
+            {
+                "provider": "vast",
+                "vast_rate_usd_hr": handle.hourly_usd,
+                "vast_gpu": handle.gpu,
+                "vast_offer_id": handle.offer_id,
+            }
+        )
+        metrics["notes"] = notes
+        return PollResult(True, metrics=metrics)
+
+    def done_is_fresh(content: str) -> bool:
+        # DONE carries the worker's time.time(); 120 s of clock-skew grace. Anything
+        # older predates this attempt (leftover from a prior attempt's resume).
+        try:
+            return float(content.strip()) > handle.started_ts - 120.0
+        except ValueError:
+            return False
+
+    poll_errors = PollErrorTracker(say, interval_s)
+
+    start = time.time()
+    last_status = None
+    last_hb_key = None
+    last_progress = time.time()
+    became_running = False
+    missing_streak = 0
+    while True:
+        if deadline_s is not None and time.time() - start > deadline_s:
+            return PollResult(False, failure="stalled", detail="client-side deadline exceeded")
+        try:
+            inst = vast_api.get_instance(handle.instance_id)
+            poll_errors.reset()
+        except vast_api.VastApiError as e:
+            if poll_errors.record(e):
+                return PollResult(False, failure="poll_error", detail=str(e))
+            continue
+        # Verified live: the instance-detail route TRANSIENTLY answers
+        # {"instances": null} for perfectly healthy instances (and for brand-new ones
+        # before they materialize). A single missing read means nothing — only a
+        # sustained streak is a real disappearance.
+        missing_streak = missing_streak + 1 if inst is None else 0
+
+        status = (inst or {}).get("actual_status") or ("missing" if inst is None else "unknown")
+        if status != last_status:
+            say(f"instance {handle.instance_id}: {status}")
+            last_status = status
+            last_progress = time.time()
+        if status == "running":
+            became_running = True
+
+        done = done_reader()
+        if done is not None and done_is_fresh(done):
+            return finish_ok(done)
+
+        if missing_streak >= 4 or status in _DEAD_STATES:
+            # One forced final read: the worker may have finished right before the
+            # instance self-destroyed (the normal success order on this substrate).
+            done = done_reader(force=True)
+            if done is not None and done_is_fresh(done):
+                return finish_ok(done)
+            raw_marker = marker_reader(force=True)
+            marker = None
+            if raw_marker:
+                with contextlib.suppress(ValueError):
+                    marker = json.loads(raw_marker)
+            return PollResult(
+                False,
+                failure="job_failed",
+                detail=_failure_detail(hf_repo, prefix, spec.phase, marker, handle.instance_id),
+            )
+
+        raw_marker = marker_reader()
+        if raw_marker:
+            try:
+                marker = json.loads(raw_marker)
+            except ValueError:
+                marker = None
+            if marker and not marker.get("ok"):
+                return PollResult(
+                    False,
+                    failure="job_failed",
+                    detail=_failure_detail(hf_repo, prefix, spec.phase, marker, handle.instance_id),
+                )
+            if marker and marker.get("ok"):
+                done = done_reader(force=True)
+                if done is not None and done_is_fresh(done):
+                    return finish_ok(done)
+
+        if not became_running and time.time() - start > LOAD_TIMEOUT_S:
+            return PollResult(
+                False,
+                failure="stalled",
+                detail=f"instance stuck in '{status}' for {int(time.time() - start)}s "
+                f"(image pull / host issue)",
+            )
+
+        new_key, _stage = surface_heartbeat(heartbeat_reader, last_hb_key, say)
+        if new_key != last_hb_key:
+            last_hb_key = new_key
+            last_progress = time.time()
+        if became_running and time.time() - last_progress > stall_after_s:
+            return PollResult(
+                False,
+                failure="stalled",
+                detail=f"no worker progress for {int(time.time() - last_progress)}s "
+                f"(instance status {status})",
+            )
+        time.sleep(interval_s)
+
+
+def submit_run_vast(
+    spec,
+    seed: int,
+    log=None,
+    on_handle=None,
+    attempt: int = 0,
+    offers: list[VastOffer] | None = None,
+    exclude_machine_ids: set[int] | frozenset[int] = frozenset(),
+) -> PollResult:
+    """Vast equivalent of ``runpod.jobs.submit_run``: rent, persist, poll.
+
+    The ``finally`` destroy is the cost-safety primary: every exit path — success,
+    failure, stall, exception, KeyboardInterrupt — tears the paid instance down.
+    """
+    if offers is None:
+        # GPU_INFO is keyed by concrete GPU class; a policy word ("cheapest"/"auto") would
+        # KeyError opaquely here. The allocator resolves policy words to a concrete class
+        # upstream, so reaching this fallback with one is a caller bug — name it clearly.
+        if spec.gpu.type not in GPU_INFO:
+            raise vast_api.VastApiError(
+                f"submit_run_vast needs a concrete gpu class, got {spec.gpu.type!r}"
+            )
+        info = GPU_INFO[spec.gpu.type]
+        offers = [
+            o
+            for o in usable_offers(
+                info.vram_gb,
+                _effective_disk_gb(spec),
+                exclude_machine_ids=exclude_machine_ids,
+                num_gpus=int(getattr(spec.gpu, "count", 1)),
+            )
+            if o.gpu == spec.gpu.type
+        ]
+    handle = deploy_and_submit(
+        spec, seed, offers, attempt=attempt, log=log, exclude_machine_ids=exclude_machine_ids
+    )
+    # The instance is rented and billing the MOMENT deploy_and_submit returns; the
+    # teardown ``finally`` must guard EVERYTHING after that point — including
+    # ``on_handle`` (persisting the remote handle can itself raise). Entering the try
+    # before on_handle guarantees the paid instance is destroyed even if the handle is
+    # never persisted, closing the rent->persist crash window's billing leak.
+    try:
+        if on_handle is not None:
+            on_handle(handle.to_dict())
+        hf_repo = spec.train.hf_repo
+        prefix = f"{spec.phase}/{spec.run_id}/seed{seed}"
+        reader = make_hf_heartbeat_reader(hf_repo, prefix) if hf_repo else None
+        stall = 1500.0
+        # Wall cap + provision/install grace; Vast has no server-side execution
+        # timeout, so the client deadline (and the bootstrap's own cap) bound spend.
+        deadline = max(60, int(spec.gpu.max_wall_seconds)) + 1800
+        return poll_vast_job(
+            handle,
+            spec,
+            seed,
+            log=log,
+            heartbeat_reader=reader,
+            stall_after_s=stall,
+            deadline_s=deadline,
+        )
+    finally:
+        vast_api.destroy_instance(handle.instance_id)
+
+
+def cancel(remote: dict) -> None:
+    """Cross-process cancel: destroy the persisted instance (stops billing)."""
+    instance_id = remote.get("instance_id")
+    if instance_id:
+        vast_api.destroy_instance(int(instance_id))
+
+
+def destroy_run_instances(run_id: str) -> list[int]:
+    """Destroy every instance belonging to ONE run (labels start with its run id).
+
+    Cancel/GC path: unlike ``sweep_orphans`` this never looks at other runs, so it
+    is safe to call while they are in flight. Best-effort: never raises.
+    """
+    destroyed: list[int] = []
+    if not run_id:
+        return destroyed
+    try:
+        instances = vast_api.list_instances()
+    except Exception:
+        return destroyed
+    prefixes = (run_id, f"autoslm-{run_id}")  # instance_label may force the prefix
+    for inst in instances:
+        iid = inst.get("id")
+        label = str(inst.get("label") or "")
+        # Match on the label boundary, not a raw string prefix (see ``sweep_orphans``):
+        # an instance label is ``f"{run_label_prefix(run_id)}-s{seed}-a{attempt}"``, so a
+        # run's prefix must equal the label or be followed by the ``-s`` seed boundary.
+        # A bare ``startswith`` would let run ``100`` also destroy run ``1000``'s instances.
+        if (
+            iid
+            and any(label == p or label.startswith(p + "-s") for p in prefixes)
+            and vast_api.destroy_instance(int(iid))
+        ):
+            destroyed.append(int(iid))
+    return destroyed
+
+
+def sweep_orphans(active_labels: set[str] | None = None) -> list[int]:
+    """Destroy AutoSLM-labeled instances that no live run owns; return destroyed ids.
+
+    Run at server startup (crash recovery) and after runs (belt and suspenders).
+    Only labels carrying the run-id prefix are ever touched — nothing else on the
+    account is ours to destroy. Best-effort: never raises.
+
+    ``active_labels`` may be RAW run ids (what the server tracks) — each is passed
+    through ``run_label_prefix`` so it matches the SAME forced-``autoslm-`` prefix the
+    instance labels carry. Passing an already-prefixed label is fine (idempotent), so a
+    live run whose id lacks the prefix is still correctly protected.
+    """
+    destroyed: list[int] = []
+    try:
+        instances = vast_api.list_instances()
+    except Exception as exc:
+        logger.warning("vast orphan sweep skipped: %s", exc)
+        return destroyed
+    active = {run_label_prefix(a) for a in (active_labels or set())}
+    for inst in instances:
+        label = str(inst.get("label") or "")
+        if not label.startswith("autoslm-"):
+            continue
+        # Match on the label boundary, not a raw string prefix: an instance label is
+        # ``f"{run_label_prefix(run_id)}-s{seed}-a{attempt}"`` (see ``instance_label``),
+        # so a live run's prefix must equal the label or be followed by the ``-s`` seed
+        # boundary. A bare ``startswith`` would let one run's prefix (e.g. ``autoslm-100``)
+        # shield another run's orphan (``autoslm-1000-...``) from the sweep.
+        if any(label == a or label.startswith(a + "-s") for a in active):
+            continue
+        iid = inst.get("id")
+        if iid and vast_api.destroy_instance(int(iid)):
+            destroyed.append(int(iid))
+            logger.warning("destroyed orphaned vast instance %s (label %s)", iid, label)
+    return destroyed

code/autoslm/providers/vast/preflight.py

@@ -0,0 +1,26 @@
+"""Fail-fast credential checks for the Vast.ai substrate (operator-side).
+
+Mirrors ``providers/runpod/preflight.py``: surfaces missing operator config as a clear
+problem list the control plane aggregates into one startup error. Vast is opt-in (it is
+only required when a run pins ``gpu.provider = "vast"`` or the operator enables it), so
+the only Vast-specific requirement is ``VAST_API_KEY``; HF_TOKEN is a shared run
+requirement checked once by the RunPod preflight (the HF dataset repo is per-run via
+``[train] hf_repo``).
+"""
+
+from __future__ import annotations
+
+from autoslm.providers.vast.auth import load_api_key
+
+
+def missing_credentials(require_hf: bool = True) -> list[str]:
+    """Vast-related operator config that is missing (empty list == ready).
+
+    ``require_hf`` is accepted only for signature parity with the RunPod check and is
+    intentionally ignored: Vast has no provider-owned HF requirement (the shared
+    HF_TOKEN is checked once centrally in ``providers.preflight``).
+    """
+    problems: list[str] = []
+    if not load_api_key():
+        problems.append("  - VAST_API_KEY: the operator's Vast.ai API key (for the vast provider)")
+    return problems

code/autoslm/providers/vast/pricing.py

@@ -0,0 +1,51 @@
+"""Vast.ai $/hr: cheapest live verified-datacenter offer per class, static fallback.
+
+RunPod prices a fixed class catalog; Vast is a live market, so a class's "rate" is the
+cheapest currently-usable offer for it (``usable_offers``). This module gives the
+provider interface a uniform ``hourly_rate(gpu)`` and a ``live_rates()`` map for the
+``slm gpus`` table. Offline-safe: AUTOSLM_SKIP_NET (or any failure) falls back to the
+static Vast snapshot carried on ``GpuClass.hourly_usd``.
+"""
+
+from __future__ import annotations
+
+import os
+
+from autoslm._logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def _static_rates() -> dict[str, float]:
+    """Static Vast snapshot rate per class with a ``vast_name`` (display-only fallback)."""
+    from autoslm.providers.base import GPU_INFO
+
+    return {name: info.hourly_usd for name, info in GPU_INFO.items() if info.vast_name}
+
+
+def live_rates(refresh: bool = False) -> dict[str, float]:
+    """Friendly-name -> cheapest live verified-datacenter $/hr (static fallback).
+
+    Offline-safe: AUTOSLM_SKIP_NET (or any fetch failure) returns the static rates.
+    """
+    static = _static_rates()
+    if os.environ.get("AUTOSLM_SKIP_NET") or not os.environ.get("VAST_API_KEY"):
+        return static
+    try:
+        from autoslm.providers.vast.jobs import usable_offers
+
+        rates: dict[str, float] = {}
+        for offer in usable_offers(0, 0):  # offers are price-sorted, cheapest first
+            rates.setdefault(offer.gpu, offer.dph_total)
+        return {**static, **rates}
+    except Exception as exc:
+        logger.warning("live vast pricing unavailable (%s); using static rates", exc)
+        return static
+
+
+def hourly_rate(gpu_name: str) -> float:
+    """$/hr for one friendly GPU name (cheapest live offer if available, else static)."""
+    from autoslm.providers.base import canonical_gpu
+
+    name = canonical_gpu(gpu_name)
+    return live_rates().get(name) or _static_rates().get(name, 0.0)

code/autoslm/providers/vast/train.py

@@ -0,0 +1,27 @@
+"""Vast.ai train submission: build the instance payload + submit a run.
+
+The worker stack/env is substrate-neutral, so the per-run worker env and dependency
+resolution are shared with RunPod (``providers/runpod/train.py``); this module owns the
+Vast-specific submission entrypoint and the instance payload shape. Provisioning,
+polling, and teardown live in ``providers/vast/jobs.py``.
+"""
+
+from __future__ import annotations
+
+# Shared, substrate-neutral worker stack (single source of truth on RunPod's module).
+from autoslm.providers.runpod.train import (
+    WORKER_DEPS,
+    WORKER_SYSTEM_DEPS,
+    build_worker_env,
+    resolve_worker_deps,
+)
+from autoslm.providers.vast.jobs import build_payload, submit_run_vast
+
+__all__ = [
+    "WORKER_DEPS",
+    "WORKER_SYSTEM_DEPS",
+    "build_payload",
+    "build_worker_env",
+    "resolve_worker_deps",
+    "submit_run_vast",
+]

code/autoslm/runner.py

@@ -0,0 +1,1037 @@
+"""Platform runner: drives managed GPUs across providers (RunPod Flash + Vast), one allocation per seed."""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import re
+import tempfile
+import threading
+import time
+import uuid
+from dataclasses import asdict, dataclass, field
+
+from .catalog import ModelInfo, resolve_model
+from .spec import JobSpec
+
+# Fixed local storage roots (not operator-configurable): run-state JSON + result artifacts,
+# both under the ~/.autoslm state dir (same root as server/db.py's DB_PATH) so a single
+# directory holds all control-plane state — mount one volume at ~/.autoslm to persist it.
+# Tests redirect them via monkeypatch.setattr(runner, "RUNS_DIR"/"RESULTS_DIR").
+_STATE_DIR = os.path.join(os.path.expanduser("~"), ".autoslm")
+RUNS_DIR = os.path.join(_STATE_DIR, "runs")
+RESULTS_DIR = os.path.join(_STATE_DIR, "results")
+TERMINAL_STATES = frozenset({"done", "failed", "cancelled", "dry_run"})
+# Terminal states a deploy must NOT overwrite. `done` is terminal but IS deployable
+# (deploying a finished run is the whole point), so it's excluded here; cancelled/failed/
+# dry_run must never be flipped to `deployed`.
+_UNDEPLOYABLE_STATES = TERMINAL_STATES - {"done"}
+# Serializes the read-check-write in _update so a status transition is an atomic
+# compare-and-set (the control plane is single-instance with per-run threads).
+_STATUS_LOCK = threading.Lock()
+
+
+def artifacts_dir(spec: JobSpec) -> str:
+    """Run-scoped artifact root: results/runpod/<phase>/<run_id>."""
+    return os.path.join(RESULTS_DIR, "runpod", spec.phase, spec.run_id)
+
+
+def adapter_prefix(spec: JobSpec, seed: int | None = None) -> str:
+    """A run's adapter location on the HF artifact store."""
+    chosen = spec.train.seeds[0] if seed is None else seed
+    return f"{spec.phase}/{spec.run_id}/seed{chosen}"
+
+
+def _gpu_rate(gpu_type: str) -> float:
+    """Representative $/hr for cost projection (live RunPod pricing, static fallback);
+    the worker also records wall time so cost = wall_hours * rate."""
+    try:
+        from autoslm.providers.runpod.pricing import hourly_rate
+
+        return hourly_rate(gpu_type)
+    except Exception:
+        return 0.80
+
+
+@dataclass
+class RunStatus:
+    run_id: str
+    state: str
+    spec: dict
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+    cost_usd: float = 0.0
+    error: str | None = None
+    artifacts_dir: str | None = None
+    deployment: dict | None = None
+    # Durable job handle {endpoint_id, endpoint_name, job_id} — lets any process
+    # reattach to / cancel the remote job (see `slm attach`).
+    remote: dict | None = None
+    # Index of the next seed to run for a multi-seed job, set while the remote handle
+    # is cleared in the gap between seeds. Lets recover_runs resume the remaining seeds
+    # after an inter-seed restart instead of failing the run (losing completed work).
+    resume_seed_index: int | None = None
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+class _RunCancelled(RuntimeError):
+    """User cancellation observed mid-run; terminal, never retried/overwritten."""
+
+
+def new_run_id(prefix: str = "autoslm") -> str:
+    return f"{prefix}-{int(time.time())}-{uuid.uuid4().hex[:8]}"
+
+
+_RUN_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
+
+
+def require_safe_run_id(run_id: str) -> str:
+    """Reject run ids that could traverse outside the runs directory.
+
+    Run ids flow from API path params into filesystem paths (status json,
+    log files); restrict them to a conservative filename alphabet.
+    """
+    if not _RUN_ID_RE.match(run_id or ""):
+        raise ValueError(f"invalid run_id: {run_id!r}")
+    return run_id
+
+
+def runs_file_path(run_id: str, suffix: str) -> str:
+    """Containment-checked path for a run's file under RUNS_DIR.
+
+    Belt and braces with require_safe_run_id: the resolved path must stay
+    inside the runs directory even if the alphabet check ever regresses.
+    """
+    base = os.path.abspath(RUNS_DIR)
+    path = os.path.normpath(os.path.join(base, f"{require_safe_run_id(run_id)}{suffix}"))
+    if not path.startswith(base + os.sep):
+        raise ValueError(f"invalid run_id: {run_id!r}")
+    return path
+
+
+def _with_model_disk(spec: JobSpec, info: ModelInfo) -> dict:
+    """Spec dict with gpu.disk_gb raised to the model's min_disk_gb (catalog).
+
+    Big-checkpoint models (whose weights alone exceed the default) need more container
+    disk than the platform's 64 GB default; this makes them work without users having
+    to know the right ``gpu.disk_gb``.
+    """
+    d = spec.to_dict()
+    need = int(getattr(info, "min_disk_gb", 0) or 0)
+    if need > int(d["gpu"].get("disk_gb") or 0):
+        d["gpu"] = {**d["gpu"], "disk_gb": need}
+    return d
+
+
+def submit_job(spec: JobSpec, dry_run: bool = False, background: bool = False) -> RunStatus:
+    """Submit a job. In real mode this allocates and provisions the cheapest validated GPU class
+    across the configured providers (RunPod Flash or Vast); dry-run only records state."""
+    info = resolve_model(spec.model, spec.algorithm, policy=spec.model_policy, gpu=spec.gpu.type)
+    # Fail fast: a disaggregated-only model (e.g. Qwen3.6-35B-A3B) can't run colocated GRPO.
+    from .engine.rollout_bench import validate_disaggregated_requirement
+
+    validate_disaggregated_requirement(
+        requires_disaggregated=info.requires_disaggregated,
+        algorithm=spec.algorithm,
+        inference_gpus=spec.train.inference_gpus,
+    )
+    spec = JobSpec.from_dict(
+        {**_with_model_disk(spec, info), "run_id": spec.run_id or new_run_id()}
+    )
+    status = RunStatus(run_id=spec.run_id, state="queued", spec=spec.to_dict())
+    _save_status(status)
+    if dry_run:
+        status.state = "dry_run"
+        _save_status(status)
+        return status
+    if background:
+        threading.Thread(target=_run_job, args=(spec,), daemon=True).start()
+        return get_status(spec.run_id)
+    _run_job(spec)
+    return get_status(spec.run_id)
+
+
+def get_status(run_id: str) -> RunStatus:
+    path = runs_file_path(run_id, ".json")
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"unknown run_id: {run_id}")
+    with open(path) as f:
+        return RunStatus(**json.load(f))
+
+
+def list_runs() -> list[RunStatus]:
+    os.makedirs(RUNS_DIR, exist_ok=True)
+    runs = []
+    for name in sorted(os.listdir(RUNS_DIR)):
+        if name.endswith(".json"):
+            with open(os.path.join(RUNS_DIR, name)) as f:
+                runs.append(RunStatus(**json.load(f)))
+    return runs
+
+
+def get_logs(run_id: str) -> str:
+    log_path = runs_file_path(run_id, ".log")
+    if not os.path.exists(log_path):
+        return ""
+    with open(log_path) as f:
+        return f.read()
+
+
+def cancel_run(run_id: str) -> RunStatus:
+    """Cancel a run: delete its remote Flash endpoint (stopping the worker), then mark it
+    cancelled.
+
+    Uses ``terminate_endpoint`` (reconstructs the run's uniquely-named endpoint and deletes it
+    via the RunPod API) so the cancel works **cross-process** — a fresh ``slm cancel`` actually
+    stops the GPU worker, instead of leaving it running until the wall cap. Best-effort: any
+    teardown error is recorded but still flips the run to ``cancelled``.
+    """
+    status = get_status(run_id)
+    if status.state in TERMINAL_STATES:
+        return status
+    # Whether the run was a live `deployed` serving run at cancel entry. This scopes the
+    # final `cancelled` transition's terminal override below: only a `deployed` run can have
+    # a concurrent undeploy (`mark_undeployed`) race this teardown and write a non-completion
+    # terminal `done`. A non-deployed run (running/provisioning/queued) has an in-flight
+    # TRAINING thread whose only terminal `done` is a GENUINE completion — which cancel must
+    # never clobber. See the final _update call for how this gates the override.
+    entered_deployed = status.state == "deployed"
+    spec = JobSpec.from_dict(status.spec)
+    remote = status.remote or {}
+    # A deployed run also owns a serving endpoint (autoslm-serve-*) that the
+    # training-endpoint GC below does not touch; tear it down too so a
+    # cancelled run can't leave a billable deployment registered. Serving is
+    # RunPod-only, so use the class actually deployed (a Vast-only training class
+    # falls back to a RunPod class at deploy time).
+    if status.state == "deployed":
+        try:
+            from autoslm.serve.deploy import undeploy_adapter
+
+            deployed_gpu = (status.deployment or {}).get("gpu") or spec.gpu.type
+            deleted = undeploy_adapter(run_id, gpu_name=deployed_gpu)
+            # Mark the deployment inactive so /v1/deployments and /chat (which gate only
+            # on the deployment record's state) stop treating the cancelled run as
+            # active. dev mode is scale-to-zero: a never-chatted dev deployment has no
+            # endpoint yet, so an empty deletion is still a clean teardown — don't leave
+            # it "ready". always-on provisions at deploy time, so only mark it inactive
+            # once a deletion is confirmed (an empty deletion there is suspicious).
+            dev_mode = (status.deployment or {}).get("mode", "dev") == "dev"
+            if status.deployment and (deleted or dev_mode):
+                # Mark the deployment inactive through the lock-guarded path so this write
+                # participates in the same _STATUS_LOCK as the rest of the runner. A bare
+                # _save_status here would persist a stale pre-teardown snapshot OUTSIDE the
+                # lock, bypassing serialization and potentially clobbering a concurrent field
+                # update. We mark ONLY the deployment field and leave the run's state alone
+                # (no state re-assert): a concurrent mark_undeployed can move the run to
+                # terminal `done` between our get_status read and this write, and _update's
+                # compare-and-set rejects ANY transition off a terminal state (even a
+                # same-field re-assert of the stale `deployed`), which would silently leave
+                # the deployment advertised as `ready`. mark_deployment_undeployed flips the
+                # deployment regardless of (and without disturbing) the current state.
+                mark_deployment_undeployed(run_id)
+        except Exception:
+            # Best-effort serving teardown: a failure here must not block the cancel
+            # below (the run still flips to cancelled and the training endpoint is GC'd).
+            pass
+    # Durable path first: stop the exact remote worker via the handle's provider
+    # (works from any process); endpoint/instance teardown is shared with the GC.
+    # Dispatched generically through the registry — never a hardcoded per-provider branch.
+    if remote:
+        try:
+            from autoslm.providers import get_provider
+            from autoslm.providers.base import JobHandle
+
+            handle = JobHandle.from_dict(remote)
+            provider = get_provider(handle.provider)
+            provider.cancel(handle)
+            # Vast bills until destroyed, so also belt-and-suspenders destroy the
+            # instance (a no-op cost-wise for runpod, whose endpoint GC follows).
+            provider.destroy(handle)
+        except Exception:
+            # Best-effort remote stop; _gc_run_endpoints below still tears the endpoint down.
+            pass
+    _gc_run_endpoints(spec)
+    # Final transition to `cancelled`. The run was NON-terminal at entry, but teardown takes
+    # time and a terminal state can race in mid-teardown. We must distinguish two cases:
+    #
+    #   - A concurrent mark_undeployed() (an external `DELETE /v1/runs/{id}/deploy`) flipped a
+    #     `deployed` run to terminal `done`. That `done` is NOT a fresh result — it just
+    #     restored the run's pre-deploy completion marker while retiring serving. The user
+    #     explicitly asked to cancel, so this must be OVERRIDDEN to `cancelled`.
+    #   - A genuine training-COMPLETION `done` from the run's own training thread
+    #     (_run_job_inner / attach_run), which persisted real metrics+cost+artifacts. Cancel
+    #     must NEVER clobber that — the run finished, so the real result is preserved.
+    #
+    # These two races are mutually exclusive on the entry state: only a `deployed` run owns a
+    # deployment that mark_undeployed can race, and only a non-deployed (running/provisioning/
+    # queued) run has an in-flight training thread that can complete mid-teardown. So scope the
+    # terminal override to runs that were `deployed` at entry — there a racing `done` is always
+    # an undeploy artifact (cancel wins); elsewhere a racing `done` is a genuine completion that
+    # _update's CAS correctly protects (cancel loses to a real finish).
+    _update(run_id, "cancelled", allow_from_terminal=entered_deployed)
+    return get_status(run_id)
+
+
+def attach_run(run_id: str, log_stream=None) -> RunStatus:
+    """Re-attach to a run's remote job from ANY process (after a client crash/restart).
+
+    Uses the persisted {endpoint_id, job_id} handle to resume polling; on completion,
+    persists metrics exactly like the original client would have, flips the state, and
+    GCs the endpoint. Raises if the run has no persisted handle (it failed or was
+    cancelled before a worker was provisioned).
+    """
+    import sys
+
+    status = get_status(run_id)
+    if status.state in TERMINAL_STATES:
+        return status
+    if not status.remote:
+        raise ValueError(f"run {run_id} has no persisted job handle; cannot reattach")
+
+    spec = JobSpec.from_dict(status.spec)
+    remote = dict(status.remote)
+    seed = int(remote.pop("seed", spec.train.seeds[0]))
+    # The class the run actually provisioned (a policy retry may have walked past the
+    # provisional spec.gpu.type). The in-process success path stamps this into metrics;
+    # on recovery the worker output carries no such field, so recover it from the handle
+    # to cost the right card.
+    allocated_gpu = remote.pop("allocated_gpu", None)
+    log = log_stream or sys.stderr
+    # Dispatch the poll generically via the handle's provider (the provider owns its
+    # heartbeat reader + poll loop); the orchestrator stays provider-agnostic.
+    from autoslm.providers import get_provider
+    from autoslm.providers.base import JobHandle
+
+    handle = JobHandle.from_dict(remote)
+    print(f"attaching to {run_id}: provider={handle.provider} {handle.data}", file=log)
+    res = get_provider(handle.provider).poll(handle, spec, seed, log=log)
+    try:
+        # A best-effort cancel deletes the job/instance, which the poller reports as a
+        # failure (or a late worker may still succeed) — either way, re-read the state
+        # first so a recovery thread can't overwrite the user's terminal `cancelled`.
+        if get_status(run_id).state == "cancelled":
+            return get_status(run_id)
+        if not res.ok:
+            _update(run_id, "failed", error=f"{res.failure}: {res.detail}")
+            return get_status(run_id)
+        # Carry the provisioned class into metrics so _persist_metrics costs the card the
+        # run actually used (the in-process path stamps this; recovery must restore it).
+        if allocated_gpu and isinstance(res.metrics, dict):
+            res.metrics.setdefault("allocated_gpu", allocated_gpu)
+        # Earlier seeds of a multi-seed run already persisted their cost into
+        # status.cost_usd; add this seed's so recovery doesn't underreport spend.
+        total = float(status.cost_usd or 0.0) + _persist_metrics(spec, seed, res.metrics)
+        # A cancel can land while this thread persists the recovered seed's metrics
+        # (after the late-cancel check above). Re-read before the post-seed writes so
+        # the "running" update and the terminal "done" below can't resurrect a
+        # user-cancelled run (mirrors the fresh seed loop). _RunCancelled is caught
+        # below, leaving the cancellation intact.
+        if get_status(run_id).state == "cancelled":
+            raise _RunCancelled(f"run {run_id} was cancelled")
+        # The remote handle only identifies the seed that was in flight. For a
+        # multi-seed run, resume the remaining seeds instead of terminally
+        # completing the whole run after just this one.
+        try:
+            resumed_index = list(spec.train.seeds).index(seed) + 1
+        except ValueError:
+            resumed_index = len(spec.train.seeds)
+        more_seeds = resumed_index < len(spec.train.seeds)
+        # Clear the now-stale completed handle before resuming. In the
+        # allocation/provisioning gap before the next seed's on_handle() persists a
+        # fresh handle, a server restart must not reattach recovery to this finished
+        # job — that would double-count its cost and replay the wrong seed. Record the
+        # next seed index so a restart in that gap resumes the remaining seeds rather
+        # than failing the run. (The last seed keeps its handle for post-run
+        # observability, mirroring the fresh-submit seed loop.)
+        _update(
+            run_id,
+            "running",
+            cost_usd=total,
+            artifacts_dir=artifacts_dir(spec),
+            **({"remote": None, "resume_seed_index": resumed_index} if more_seeds else {}),
+        )
+        if more_seeds:
+            _run_seed_loop(spec, log, start_index=resumed_index, prior_cost=total)
+        else:
+            _update(run_id, "done", cost_usd=total, artifacts_dir=artifacts_dir(spec))
+    except _RunCancelled:
+        # Intentional: cancel_run already wrote the terminal `cancelled` state; leave it.
+        pass
+    except Exception as exc:
+        if get_status(run_id).state != "cancelled":
+            _update(run_id, "failed", error=str(exc))
+    finally:
+        _gc_run_endpoints(spec)
+    return get_status(run_id)
+
+
+def resume_run(run_id: str, log_stream=None) -> RunStatus:
+    """Resume the remaining seeds of a multi-seed run after a restart in the inter-seed gap.
+
+    Between two seeds the completed seed's handle is cleared and ``resume_seed_index`` is
+    recorded (see ``_run_seed_loop``). A control-plane restart in that handle-less window
+    must RESUME from that index rather than fail the run and discard the finished seeds.
+    Unlike ``attach_run`` there is no live job to poll — the prior process already tore the
+    seed's endpoint down — so we start a fresh seed loop from the recorded index. The slm
+    package was uploaded to HF on the original submit, so the worker can still fetch it; no
+    re-upload is needed.
+    """
+    import sys
+
+    status = get_status(run_id)
+    if status.state in TERMINAL_STATES:
+        return status
+    if status.resume_seed_index is None:
+        raise ValueError(f"run {run_id} has no resume_seed_index; cannot resume")
+    spec = JobSpec.from_dict(status.spec)
+    log = log_stream or sys.stderr
+    print(f"resuming {run_id}: remaining seeds from index {status.resume_seed_index}", file=log)
+    try:
+        _run_seed_loop(
+            spec,
+            log,
+            start_index=status.resume_seed_index,
+            prior_cost=float(status.cost_usd or 0.0),
+        )
+    except _RunCancelled:
+        pass  # cancel_run already set the terminal state
+    except Exception as exc:
+        if get_status(run_id).state != "cancelled":
+            _update(run_id, "failed", error=str(exc))
+    finally:
+        # Mirror _run_job: GC any endpoint a transient destroy left behind rather than
+        # leaking a billable RunPod endpoint.
+        _gc_run_endpoints(spec)
+    return get_status(run_id)
+
+
+def mark_deployed(run_id: str, deployment: dict, expect_state: str | None = None) -> RunStatus:
+    # Atomic + terminal-respecting (same guard as _update): a /cancel landing during
+    # always-on provisioning/warmup writes `cancelled`; this must NOT overwrite it with
+    # `deployed` and resurrect the run as an active deployment. `done` is deployable
+    # though (the common case: deploy a finished run), so only the non-`done` terminal
+    # states block here — otherwise a freshly finished run could never be deployed.
+    #
+    # expect_state is a compare-and-set: the deploy flow passes the state it expects the
+    # run to still be in (the pre-deploy snapshot, or "deployed" after the provisional
+    # mark). If an undeploy raced finalization — deleting the endpoint and writing `done`
+    # with deployment.state="undeployed" mid-warmup — the state no longer matches and we
+    # refuse to re-advertise the just-deleted endpoint.
+    with _STATUS_LOCK:
+        status = get_status(run_id)
+        if status.state in _UNDEPLOYABLE_STATES:
+            return status
+        if expect_state is not None and status.state != expect_state:
+            return status
+        status.deployment = deployment
+        status.state = "deployed"
+        status.updated_at = time.time()
+        _save_status(status)
+        return status
+
+
+def mark_undeployed(run_id: str) -> RunStatus:
+    """Record an explicit undeploy (endpoint torn down -> run back to `done`).
+
+    Lock-guarded so it serializes with a racing deploy finalization: the raw read +
+    _save_status the endpoint used to do could interleave with mark_deployed and be
+    clobbered. With this under the same lock, mark_deployed's expect_state CAS then sees
+    the `done`/undeployed write and won't re-advertise the deleted endpoint.
+    """
+    with _STATUS_LOCK:
+        status = get_status(run_id)
+        if status.deployment:
+            status.deployment = {**status.deployment, "state": "undeployed"}
+        # Record the teardown but don't resurrect a terminal run: undeploying a
+        # cancelled/failed run keeps its terminal state (only a live `deployed` run goes
+        # back to `done`). `done` is terminal too, so this naturally no-ops the state.
+        if status.state not in TERMINAL_STATES:
+            status.state = "done"
+        status.updated_at = time.time()
+        _save_status(status)
+        return status
+
+
+def mark_deployment_undeployed(run_id: str) -> RunStatus:
+    """Flip ONLY the deployment field to ``undeployed``, leaving the run's state untouched.
+
+    Used by ``cancel_run`` to retire a deployed run's serving record. Unlike
+    ``mark_undeployed`` (which is a state transition: a live `deployed` run goes back to
+    `done`), this never asserts or changes the run state. That matters under the cancel
+    race: a concurrent ``mark_undeployed`` may have already moved the run to terminal
+    `done`, and ``_update``'s compare-and-set rejects any transition off a terminal state —
+    even re-asserting `deployed` to carry the deployment field — which would leave the
+    deployment advertised as `ready`. Marking the field directly (lock-guarded for
+    serialization) sidesteps the CAS so the deployment reliably ends `undeployed`, while the
+    trailing ``cancelled`` transition is left to ``_update``.
+    """
+    with _STATUS_LOCK:
+        status = get_status(run_id)
+        if status.deployment:
+            status.deployment = {**status.deployment, "state": "undeployed"}
+            status.updated_at = time.time()
+            _save_status(status)
+        return status
+
+
+def rollback_deploy(run_id: str, snapshot: RunStatus) -> None:
+    """Restore the pre-deploy state/deployment after always-on provisioning fails.
+
+    Lock-guarded + terminal-respecting (same guard as _update/mark_deployed): a /cancel
+    that landed during provisioning/warmup already persisted `cancelled`; restoring the
+    pre-deploy snapshot must NOT overwrite it and resurrect the run as `done`/`deployed`.
+    """
+    with _STATUS_LOCK:
+        status = get_status(run_id)
+        if status.state in TERMINAL_STATES:
+            return
+        status.state = snapshot.state
+        status.deployment = snapshot.deployment
+        status.updated_at = time.time()
+        _save_status(status)
+
+
+def _run_job(spec: JobSpec) -> None:
+    # Lazy import so dry-run / unit tests never construct a Flash endpoint.
+    from autoslm.providers.runpod.train import upload_code
+
+    # A cancel can land between the queued status being returned to the client and
+    # this background thread starting; don't overwrite a terminal state (cancelled)
+    # with provisioning and then launch a paid seed as if the cancel never happened.
+    if get_status(spec.run_id).state in TERMINAL_STATES:
+        return
+    _update(spec.run_id, "provisioning")
+    log_path = os.path.join(RUNS_DIR, f"{spec.run_id}.log")
+    try:
+        _run_job_inner(spec, log_path, upload_code)
+    finally:
+        # Endpoint GC: every run leaves its uniquely-named endpoint registered, and the
+        # account-wide *max workers quota* (5 by default) counts registered endpoints —
+        # after a handful of runs, ALL new submissions fail with "Max workers across all
+        # endpoints must not exceed your workers quota". Tear ours down on any terminal
+        # state (best-effort; never raises).
+        _gc_run_endpoints(spec)
+
+
+def _spec_with_gpu(spec: JobSpec, gpu_type: str) -> JobSpec:
+    """The spec the workers/loggers see for THIS attempt's allocated class."""
+    if spec.gpu.type == gpu_type:
+        return spec
+    d = spec.to_dict()
+    d["gpu"] = {**d["gpu"], "type": gpu_type}
+    return JobSpec.from_dict(d)
+
+
+def _submit_seed_supervised(spec: JobSpec, seed: int, log) -> dict:
+    """Run one seed with the job submit/poll path + bounded auto-retry.
+
+    Each attempt first ALLOCATES the GPU: the cheapest class across providers (RunPod
+    live pricing + Vast verified-datacenter offers) that fits the model — re-resolved
+    fresh per attempt because offers are a live market. A policy ``gpu.requested``
+    ("cheapest"/"auto") lets the allocator pick the class; a concrete ``gpu.requested``
+    pins the class (the allocator then only picks the provider); ``gpu.provider`` pins
+    the substrate.
+
+    Retries (fresh job on a fresh host; worker resumes from the latest HF
+    checkpoint) when the failure looks infra-shaped: a stall (heartbeat frozen), a
+    client polling breakdown, or a platform TIMED_OUT/worker-loss. Sick Vast machines
+    are blacklisted for the run; failover naturally crosses providers.
+    Genuine worker errors (the run's code crashed; traceback persisted to HF) fail
+    immediately. The offline test/CI marker AUTOSLM_SKIP_NET takes the blocking
+    in-process submit instead (the job poll path is network-only).
+    """
+    from autoslm.providers.base import PollResult
+    from autoslm.providers.runpod.train import submit_train
+
+    if os.environ.get("AUTOSLM_SKIP_NET"):
+        return submit_train(spec, seed, log=log)
+
+    from autoslm.providers import get_provider
+    from autoslm.providers.allocator import allocate, allocation_summary
+    from autoslm.providers.base import POLICY_NAMES
+
+    last_handle: dict = {}
+    # The friendly GPU class the CURRENT attempt provisioned (set right before each submit),
+    # so on_handle persists it into the run handle and a recovery via attach_run costs the
+    # class actually used rather than the parse-time provisional spec.gpu.type.
+    current_gpu: dict = {}
+    # Every RunPod endpoint id this run registered across attempts. Retries run on
+    # rN-suffixed endpoints whose names _gc_run_endpoints cannot reconstruct, and a
+    # failed delete during the next attempt's teardown would otherwise lose the id;
+    # GC the whole set at exit so no retry endpoint leaks against the worker quota.
+    seen_endpoints: set[str] = set()
+
+    def on_handle(handle: dict):
+        last_handle.clear()
+        last_handle.update(handle)
+        if handle.get("endpoint_id"):
+            seen_endpoints.add(handle["endpoint_id"])
+        _update(
+            spec.run_id,
+            "running",
+            remote={**handle, "seed": int(seed), "allocated_gpu": current_gpu.get("name")},
+        )
+
+    def _gc_seen_endpoints() -> None:
+        if not seen_endpoints:
+            return
+        from autoslm.providers.runpod import api as runpod_api
+
+        for eid in seen_endpoints:
+            with contextlib.suppress(Exception):
+                runpod_api.delete_endpoint(eid)
+
+    max_retries = int(spec.gpu.max_retries)
+    last_detail = None
+    bad_machines: set[int] = set()
+    # Re-allocate freely for policy requests ("cheapest"/"auto"); honor a concrete
+    # user pin by passing it through as the only candidate class.
+    requested = (spec.gpu.requested or "").strip().lower()
+    pinned_gpu = None if requested in POLICY_NAMES else spec.gpu.type
+    # Index into the ranked candidate list. It advances only after an attempt that
+    # actually provisioned a class lost it to an infra failure (see the retry tail), so a
+    # failed allocation — which never tried a card — can't skip past the cheapest class.
+    gpu_walk_offset = 0
+    # Two independent budgets. ``crash_retries`` (bounded by max_retries) covers genuine
+    # infra flakes (host died, network timeout) where we re-provision the SAME-or-next class.
+    # ``capacity walks`` are different: a ``no_capacity`` (throttled / stuck IN_QUEUE) result
+    # just means "this class has no free workers right now" — so we WALK to the next-cheapest
+    # candidate WITHOUT spending the crash budget and WITHOUT blacklisting the class (it may
+    # free up; we simply prefer one that's available now). Bounded by the candidate count so a
+    # fully-throttled market terminates instead of looping forever.
+    crash_retries = 0
+    attempt = -1
+    while True:
+        attempt += 1
+        if attempt > 0 and last_handle:
+            # A stalled/timed-out attempt often means the worker is pinned to a
+            # throttled/sick host; tear it down so the fresh deploy lands elsewhere.
+            # Dispatched generically via the handle's provider.
+            if last_handle.get("provider") == "vast":
+                with contextlib.suppress(Exception):
+                    from autoslm.providers import get_provider
+                    from autoslm.providers.base import JobHandle
+
+                    get_provider("vast").destroy(JobHandle.from_dict(last_handle))
+                if last_handle.get("machine_id"):
+                    bad_machines.add(int(last_handle["machine_id"]))
+                print(
+                    f"retry {attempt}: destroyed vast instance "
+                    f"{last_handle.get('instance_id')} (machine "
+                    f"{last_handle.get('machine_id')} blacklisted for this run)",
+                    file=log,
+                    flush=True,
+                )
+            elif last_handle.get("endpoint_id"):
+                try:
+                    from autoslm.providers.runpod import api as runpod_api
+
+                    runpod_api.cancel_job(last_handle["endpoint_id"], last_handle["job_id"])
+                    runpod_api.delete_endpoint(last_handle["endpoint_id"])
+                    print(
+                        f"retry {attempt}: deleted endpoint {last_handle['endpoint_id']} "
+                        "(escaping throttled/sick host)",
+                        file=log,
+                        flush=True,
+                    )
+                except Exception:
+                    # Logging the host-escape note is cosmetic; never let it abort the retry.
+                    pass
+            # The previous endpoint is now deleted; clear the persisted handle so a cancel
+            # or control-plane restart during the fresh deploy doesn't operate on (or get
+            # shielded by) the dead handle. The next on_handle() records the new one.
+            with contextlib.suppress(FileNotFoundError):
+                st = get_status(spec.run_id)
+                if st.state not in TERMINAL_STATES and st.remote is not None:
+                    _update(spec.run_id, st.state, remote=None)
+        res = None
+        alloc = None
+        chosen = None
+        # A cancel can land after _run_seed_loop's pre-submit check but while
+        # allocation/pricing runs, when no handle exists yet for cancel_run() to
+        # delete. Re-read state right before paid provisioning so a cancelled run
+        # never launches a worker (the later checks only stop the final-state
+        # overwrite, after the GPU has already run and billed).
+        with contextlib.suppress(FileNotFoundError):
+            if get_status(spec.run_id).state == "cancelled":
+                raise _RunCancelled(f"run {spec.run_id} was cancelled")
+        try:
+            alloc = allocate(
+                spec.model,
+                spec.algorithm,
+                gpu=pinned_gpu,
+                provider=spec.gpu.provider,
+                disk_gb=spec.gpu.disk_gb,
+                allow_unvalidated=spec.gpu.allow_unvalidated,
+                exclude_machine_ids=frozenset(bad_machines),
+                # Multi-GPU: the allocator must search for offers with this many GPUs (Vast) — else
+                # it builds the offer book at num_gpus=1 and a disaggregated run rents a 1-GPU
+                # instance (the real cause of "container has 1 GPU"). RunPod gets gpu_count on the
+                # endpoint separately (deploy_train_endpoint).
+                gpu_count=int(getattr(spec.gpu, "count", 1)),
+                # Pass the run's train knobs + thinking so the VRAM estimate reflects THIS job's
+                # max_length / group_size / batch_size / lora_rank (and the seq escalation) instead
+                # of the generic defaults — else a long-context / big-group run is sized at seq=1024
+                # and OOMs the card it picks.
+                train=spec.train,
+                thinking=spec.thinking,
+            )
+        except Exception as exc:
+            from autoslm.providers.base import UnsupportedGpuError
+
+            if isinstance(exc, UnsupportedGpuError):
+                raise  # config-shaped: no GPU anywhere can run this job
+            res = PollResult(False, failure="poll_error", detail=f"allocation: {exc}")
+        if alloc is not None:
+            # allocate() above ran a live-market price walk; re-check cancellation
+            # right before provisioning so a cancel during allocation doesn't still
+            # launch a paid worker.
+            with contextlib.suppress(FileNotFoundError):
+                if get_status(spec.run_id).state == "cancelled":
+                    raise _RunCancelled(f"run {spec.run_id} was cancelled")
+            # Walk down the ranked candidates by the walk offset (clamped to the last): the
+            # first attempt takes the cheapest; each retry that provisioned a class and lost
+            # it to an infra failure steps to the next-cheapest, so a capacity-starved class
+            # can't burn the whole budget. A concrete pin yields a single candidate, so the
+            # clamp keeps a pinned run on its class.
+            chosen = alloc.candidates[min(gpu_walk_offset, len(alloc.candidates) - 1)]
+            print(allocation_summary(alloc), file=log, flush=True)
+            if chosen.gpu != alloc.gpu:
+                print(
+                    f"retry {attempt}: walking past the cheapest class to {chosen.gpu} "
+                    f"@ ${chosen.hourly_usd:.2f}/hr",
+                    file=log,
+                    flush=True,
+                )
+            run_spec = _spec_with_gpu(spec, chosen.gpu)
+            current_gpu["name"] = chosen.gpu
+            provider = get_provider(chosen.provider)
+            # Vast needs the live-market offer book for the chosen class first, then the
+            # other allocator-approved classes by price; RunPod ignores ``offers``.
+            offers = None
+            if chosen.provider == "vast":
+                ok_classes = {c.gpu for c in alloc.candidates if c.provider == "vast"}
+                offers = sorted(
+                    (o for o in alloc.provider_offers if o.gpu in ok_classes),
+                    key=lambda o: (o.gpu != chosen.gpu, o.dph_total),
+                )
+            try:
+                res = provider.submit_run(
+                    run_spec,
+                    seed,
+                    log=log,
+                    on_handle=on_handle,
+                    attempt=attempt,
+                    offers=offers,
+                    # The run's machine blacklist must reach the provider so an in-provider
+                    # offer REFRESH (Vast) keeps stalled/sick machines excluded.
+                    exclude_machine_ids=frozenset(bad_machines),
+                )
+            except Exception as exc:
+                # Deploy/submit themselves can fail transiently (observed: RunPod
+                # GraphQL "Something went wrong" x3 during a retry deploy; a vast offer
+                # pool emptying between search and rent). That must consume a retry, not
+                # kill the run — the budget exists precisely for flakes.
+                res = PollResult(False, failure="poll_error", detail=f"deploy/submit: {exc}")
+                if crash_retries < max_retries:
+                    time.sleep(10 * (crash_retries + 1))  # let the transient clear
+        if res.ok:
+            # A best-effort cancel may fail to stop the worker, which then completes
+            # successfully after cancel_run() persisted `cancelled`. Don't let a late
+            # worker success resurrect the run into running/done.
+            try:
+                if get_status(spec.run_id).state == "cancelled":
+                    raise _RunCancelled(f"run {spec.run_id} was cancelled")
+            except FileNotFoundError:
+                # Status file not yet written (early race): treat as not-cancelled, proceed.
+                pass
+            # Worker is done (DONE sentinel seen); GC every endpoint this seed used,
+            # including intermediate rN retries _gc_run_endpoints can't name.
+            _gc_seen_endpoints()
+            # Record the class actually allocated so _persist_metrics rates the right
+            # RunPod card when a policy GPU was re-allocated away from the provisional.
+            if chosen is not None and isinstance(res.metrics, dict):
+                res.metrics.setdefault("allocated_gpu", chosen.gpu)
+            return res.metrics
+        last_detail = f"{res.failure}: {res.detail}"
+        # Infra-shaped failures are retried on a FRESH endpoint/host; genuine worker
+        # code errors are not. Detail markers cover the observed flake classes:
+        # platform timeouts, worker pip-install network timeouts, and sick-GPU hosts.
+        _infra_markers = (
+            "TIMED_OUT",
+            "Failed to fetch",
+            "operation timed out",
+            "python_dependencies failed",
+            "Connection reset",
+            "cuda not available",
+            "GPU never became ready",
+            # Host vanished mid-run: the instance went "missing"/dead and NOTHING was captured
+            # (no marker error, no error_<phase>.txt, no console log) so _failure_detail falls back
+            # to this bare sentinel. A genuine worker code crash instead yields a RICHER detail
+            # (the captured traceback), so this exact phrase only ever marks a dead host -> retry it
+            # on a fresh one. Without this, a single ~1-in-200 host death killed the whole run.
+            "terminated without a DONE sentinel",
+        )
+        infra_shaped = res.failure in ("stalled", "poll_error", "no_capacity") or any(
+            m in (res.detail or "") for m in _infra_markers
+        )
+        # A cancel deletes the endpoint, which the poller sees as an
+        # infra-shaped failure; retrying would resurrect the run and keep
+        # billing. The user's cancel wins over the retry budget.
+        try:
+            if get_status(spec.run_id).state == "cancelled":
+                raise _RunCancelled(f"run {spec.run_id} was cancelled")
+        except FileNotFoundError:
+            # Status file not yet written (early race): treat as not-cancelled and proceed.
+            pass
+        # A capacity walk (no_capacity: the class is throttled / has no free workers right now)
+        # hops to the next-cheapest candidate WITHOUT spending the crash-retry budget and WITHOUT
+        # blacklisting the class — we just prefer one that's available now. It stops only once
+        # every candidate class has been tried (a fully-throttled market). A genuine infra crash
+        # (host died / network) instead spends the bounded crash budget.
+        is_capacity = res.failure == "no_capacity"
+        ncand = len(alloc.candidates) if alloc is not None else 0
+        if is_capacity:
+            can_retry = infra_shaped and chosen is not None and gpu_walk_offset < ncand - 1
+        else:
+            can_retry = infra_shaped and crash_retries < max_retries
+        print(
+            f"seed={seed} attempt={attempt} failed ({res.failure}); "
+            f"{'retrying (resume from last checkpoint)' if can_retry else 'not retrying'}"
+            f"\n--- failure detail ---\n{(res.detail or '')[:2000]}\n---",
+            file=log,
+            flush=True,
+        )
+        if not can_retry:
+            break
+        # Advance to the next-cheapest candidate when THIS attempt actually provisioned one.
+        # An allocation/pricing failure (chosen is None) never tried a card, so the next attempt
+        # must retry from the cheapest, not walk past it.
+        if chosen is not None:
+            gpu_walk_offset += 1
+            if is_capacity:
+                print(
+                    f"retry: {chosen.gpu} had no free workers (throttled / capacity-starved); "
+                    "walking to the next-cheapest available class (not blacklisting it)",
+                    file=log,
+                    flush=True,
+                )
+        if not is_capacity:
+            crash_retries += 1
+    # Retry budget exhausted: GC every endpoint this seed registered (the final
+    # attempt's is in status.remote for _gc_run_endpoints, but intermediate rN ones
+    # are only known here).
+    _gc_seen_endpoints()
+    raise RuntimeError(f"seed {seed} failed after retries: {last_detail}")
+
+
+def _run_job_inner(spec: JobSpec, log_path: str, upload_code) -> None:
+    try:
+        # Ship the slm package to the run's HF repo (the per-run [train] hf_repo) so the GPU
+        # worker — which fetches code/** from that same repo — can run it.
+        upload_code(spec.train.hf_repo)
+        with open(log_path, "a") as log:
+            _run_seed_loop(spec, log, start_index=0, prior_cost=0.0)
+    except _RunCancelled:
+        return  # cancel_run already set the terminal state
+    except Exception as exc:
+        if get_status(spec.run_id).state != "cancelled":
+            _update(spec.run_id, "failed", error=str(exc))
+        raise
+
+
+def _run_seed_loop(spec: JobSpec, log, *, start_index: int, prior_cost: float) -> None:
+    """Run spec.train.seeds[start_index:] under supervision; finalize the run.
+
+    Shared by a fresh submit (start_index=0) and post-restart recovery, which
+    resumes the remaining seeds after the in-flight one completes."""
+    total_cost = prior_cost
+    seeds = spec.train.seeds
+    for i in range(start_index, len(seeds)):
+        seed = seeds[i]
+        # An early cancel (before any remote handle existed) sets `cancelled`;
+        # do not overwrite it with `running` and submit the GPU job anyway.
+        if get_status(spec.run_id).state == "cancelled":
+            raise _RunCancelled(f"run {spec.run_id} was cancelled")
+        _update(spec.run_id, "running")
+        print(
+            f"starting seed={seed} phase={spec.phase} model={spec.model} gpu={spec.gpu.type}",
+            file=log,
+            flush=True,
+        )
+        metrics = _submit_seed_supervised(spec, seed, log)
+        total_cost += _persist_metrics(spec, seed, metrics)
+        # A cancel can land while this thread writes metrics — after the supervised
+        # late-cancel check. Re-read before the post-seed status writes so a late
+        # worker success doesn't resurrect a user-cancelled run via this "running"
+        # update (or the final "done" below).
+        with contextlib.suppress(FileNotFoundError):
+            if get_status(spec.run_id).state == "cancelled":
+                raise _RunCancelled(f"run {spec.run_id} was cancelled")
+        # If more seeds follow, this seed's endpoint/instance is already torn down, so
+        # clear the now-stale remote handle: a restart in the gap before the next
+        # seed's on_handle must not make recover_runs reattach to a deleted handle and
+        # fail the run. Record the next seed index so a restart in that handle-less gap
+        # RESUMES the remaining seeds (recover_runs) instead of discarding the completed
+        # ones. The last seed keeps its handle for post-run observability (the run is
+        # about to go terminal, which recover_runs never reattaches).
+        more_seeds = (i + 1) < len(seeds)
+        _update(
+            spec.run_id,
+            "running",
+            cost_usd=total_cost,
+            **({"remote": None, "resume_seed_index": i + 1} if more_seeds else {}),
+        )
+        print(
+            f"seed={seed} done: train_wall={metrics.get('wall_seconds')} cost_usd={total_cost:.4f}",
+            file=log,
+            flush=True,
+        )
+    # Final guard: a cancel landing after the last seed's check must not be overwritten
+    # by the terminal "done".
+    with contextlib.suppress(FileNotFoundError):
+        if get_status(spec.run_id).state == "cancelled":
+            raise _RunCancelled(f"run {spec.run_id} was cancelled")
+    _update(
+        spec.run_id,
+        "done",
+        cost_usd=total_cost,
+        artifacts_dir=artifacts_dir(spec),
+        resume_seed_index=None,
+    )
+
+
+def _gc_run_endpoints(spec: JobSpec) -> None:
+    """Best-effort teardown of every endpoint a run may have registered.
+
+    Retried attempts run on rN-suffixed endpoints whose runpod_flash state is
+    isolated per-suffix, so the name-based terminate_endpoint cannot see them;
+    the persisted remote handle's endpoint id covers whichever attempt ran
+    last via the plain REST API."""
+    status = None
+    with contextlib.suppress(Exception):
+        status = get_status(spec.run_id)
+    if status is not None and status.remote:
+        try:
+            from autoslm.providers import get_provider
+            from autoslm.providers.base import JobHandle
+
+            handle = JobHandle.from_dict(status.remote)
+            get_provider(handle.provider).destroy(handle)
+        except Exception:
+            # Best-effort GC; the name-reconstructed RunPod gc below is the backstop.
+            pass
+    try:
+        # RunPod's gc reaps rN-suffixed endpoints the persisted handle can't name.
+        from autoslm.providers import get_provider
+
+        get_provider("runpod").gc(spec)
+    except Exception:
+        # Best-effort GC; an undeleted endpoint only holds worker quota, never blocks the run.
+        pass
+    # Vast instances bill until destroyed: the runner's per-attempt `finally` already
+    # destroys them, but a crashed supervisor thread can leave one behind. Reap any
+    # instance still labeled for this run via the provider's gc (best-effort).
+    from autoslm.providers import available_providers, get_provider
+
+    if "vast" in available_providers():
+        with contextlib.suppress(Exception):
+            get_provider("vast").gc(spec)
+
+
+def _persist_metrics(spec: JobSpec, seed: int, metrics: dict) -> float:
+    """Write metrics to results/runpod/<phase>/<run_id>/seedN and return the cost.
+
+    The run id keeps concurrent/sequential runs of the same phase+seed from
+    overwriting each other's artifacts. Vast runs arrive with ``cost_usd`` already
+    stamped from the offer's real $/hr (plus provider notes) and short-circuit the
+    rate fallback below (the RunPod projection)."""
+    dest = os.path.join(artifacts_dir(spec), f"seed{seed}")
+    os.makedirs(dest, exist_ok=True)
+    # Rate the actually-allocated class, not the parse-time provisional spec.gpu.type:
+    # a policy GPU can be re-allocated to a different RunPod class at submit time, so
+    # the worker stamps "allocated_gpu" into metrics for the cost fallback below.
+    gpu_type = metrics.get("allocated_gpu") or spec.gpu.type
+    rate = _gpu_rate(gpu_type)
+    # A non-runpod provider (e.g. Vast) stamps the real cost_usd from its offer's $/hr
+    # AND tags notes["provider"] with its own name — and a near-zero-duration run can
+    # legitimately stamp cost_usd == 0.0. The RunPod arm, by contrast, never stamps a real
+    # cost: it arrives with cost_usd absent (or a 0.0 placeholder) and no provider note, so
+    # the wall-based projection below must run. A bare `cost or 0.0` would treat the Vast
+    # 0.0 as "absent" and re-rate it against RunPod pricing while overwriting the provider
+    # notes, mis-attributing the run to 'runpod'. So fall back only when the cost is
+    # missing/zero AND it has NOT already been attributed to a non-runpod provider.
+    _notes = metrics.get("notes")
+    _stamped_provider = _notes.get("provider") if isinstance(_notes, dict) else None
+    _non_runpod = bool(_stamped_provider) and _stamped_provider != "runpod"
+    cost = metrics.get("cost_usd")
+    if cost or _non_runpod:
+        cost = float(cost or 0.0)
+    else:
+        wall = float(metrics.get("wall_seconds") or 0.0)
+        cost = wall / 3600.0 * rate
+        metrics = {**metrics, "cost_usd": cost}
+        metrics.setdefault("notes", {})
+        if isinstance(metrics["notes"], dict):
+            metrics["notes"]["provider"] = "runpod"
+            metrics["notes"]["runpod_rate_usd_hr"] = rate
+            metrics["notes"]["runpod_gpu"] = gpu_type
+    with open(os.path.join(dest, "metrics.json"), "w") as f:
+        json.dump(metrics, f, indent=2)
+    return float(cost)
+
+
+def _update(run_id: str, state: str, *, allow_from_terminal: bool = False, **updates) -> None:
+    # The read-check-write below must be atomic: a concurrent `slm cancel` (also via
+    # _update) landing between the get_status read and the _save_status write could
+    # otherwise be clobbered by this stale background update, resurrecting a cancelled
+    # run. The control plane is single-instance with per-run threads, so a process-wide
+    # lock serializes all status transitions into a compare-and-set.
+    with _STATUS_LOCK:
+        status = get_status(run_id)
+        # Terminal states are STICKY: once a run is done/failed/cancelled/dry_run, no
+        # other state may overwrite it. This closes the whole cancel-race class at the
+        # source — a cancel landing between a caller's check and a later write
+        # (provisioning/running, or even a late terminal done/failed from a worker that
+        # finished as the cancel arrived) can no longer resurrect the run. Same-state
+        # writes still pass so terminal field updates (cost_usd, error, artifacts_dir)
+        # are preserved.
+        #
+        # allow_from_terminal is the NARROW escape hatch used ONLY by cancel_run's final
+        # `cancelled` transition, and ONLY when the run was `deployed` at cancel entry (see
+        # cancel_run). In that case an explicit user cancel must WIN over a racing
+        # mark_undeployed() that flipped the `deployed` run to terminal `done` mid-teardown —
+        # that `done` is an undeploy artifact (restoring the pre-deploy completion marker while
+        # retiring serving), not a fresh result. Without the override the `cancelled` write
+        # no-ops against the freshly-written `done` and the run wrongly ends `done` despite the
+        # user asking to cancel. cancel_run passes allow_from_terminal=False for a non-deployed
+        # run, so a GENUINE training-completion `done` racing in from the run's own training
+        # thread is protected by the CAS below — cancel correctly loses to a real finish.
+        if status.state in TERMINAL_STATES and state != status.state and not allow_from_terminal:
+            return
+        status.state = state
+        status.updated_at = time.time()
+        for key, value in updates.items():
+            setattr(status, key, value)
+        _save_status(status)
+
+
+def _save_status(status: RunStatus) -> None:
+    os.makedirs(RUNS_DIR, exist_ok=True)
+    # Write-then-rename: a concurrent reader (poll on /v1/runs or /logs) must
+    # never observe a half-written/truncated file and 500 on JSONDecodeError.
+    # The temp name is UNIQUE per write (mkstemp) so two threads updating the same
+    # run (e.g. a cancel racing the background seed update) can't clobber each
+    # other's temp file mid-dump — each os.replace is atomic and independent.
+    path = runs_file_path(status.run_id, ".json")
+    fd, tmp = tempfile.mkstemp(dir=RUNS_DIR, prefix=f"{status.run_id}.", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            json.dump(status.to_dict(), f, indent=2, sort_keys=True)
+        os.replace(tmp, path)
+    finally:
+        with contextlib.suppress(FileNotFoundError):
+            os.unlink(tmp)

code/autoslm/schema.py

@@ -0,0 +1,438 @@
+"""Parse AutoSLM TOML configs into worker JobSpecs."""
+
+from __future__ import annotations
+
+import math
+import tomllib
+from typing import Any
+
+from .catalog import normalize_algorithm, resolve_model
+from .providers import PROVIDER_NAMES
+from .providers.base import (
+    POLICY_NAMES,
+    SUPPORTED,
+    UnsupportedGpuError,
+    canonical_gpu,
+    is_validated,
+    providers_for,
+    resolve_gpu_policy,
+    unvalidated_allowed,
+)
+from .spec import EnvironmentSpec, GpuSpec, JobSpec, TrainSpec
+
+
+def _train_int(train_raw: dict, key: str, *, minimum: int) -> int | None:
+    """Validate an optional integer [train] knob (>= minimum) -> ConfigError (HTTP 400).
+
+    None stays None (recipe default). Rejects bools, non-numbers, non-integers, and
+    out-of-range values at parse time instead of letting them reach a provisioned worker.
+    """
+    v = train_raw.get(key)
+    if v is None:
+        return None
+    if isinstance(v, bool) or not isinstance(v, (int, float)):
+        raise ConfigError(f"train.{key} must be an integer")
+    # Check finiteness BEFORE int(v): int(inf) raises OverflowError and int(nan) ValueError
+    # (the former would be a 500); reject both as a clean 400.
+    if not math.isfinite(v) or float(v) != int(v):
+        raise ConfigError(f"train.{key} must be a finite integer")
+    v = int(v)
+    if v < minimum:
+        raise ConfigError(f"train.{key} must be >= {minimum}")
+    return v
+
+
+def _train_float(
+    train_raw: dict,
+    key: str,
+    *,
+    minimum: float,
+    exclusive: bool = False,
+    maximum: float | None = None,
+) -> float | None:
+    """Validate an optional float [train] knob -> ConfigError (HTTP 400). None stays None."""
+    v = train_raw.get(key)
+    if v is None:
+        return None
+    if isinstance(v, bool) or not isinstance(v, (int, float)):
+        raise ConfigError(f"train.{key} must be a number")
+    v = float(v)
+    # nan/inf slip past the range checks below (nan compares false, inf passes any minimum)
+    # and would reach TRL optimizer/sampling settings; reject them as a 400 here.
+    if not math.isfinite(v):
+        raise ConfigError(f"train.{key} must be a finite number")
+    if exclusive and v <= minimum:
+        raise ConfigError(f"train.{key} must be > {minimum}")
+    if not exclusive and v < minimum:
+        raise ConfigError(f"train.{key} must be >= {minimum}")
+    if maximum is not None and v > maximum:
+        raise ConfigError(f"train.{key} must be between {minimum} and {maximum}")
+    return v
+
+
+def _train_stops(train_raw: dict) -> tuple[str, ...]:
+    """Validate stop_sequences -> ConfigError. A string is ONE stop (never char-split);
+    a list must hold strings; empties are dropped; anything else is rejected."""
+    v = train_raw.get("stop_sequences")
+    if v is None:
+        return ()
+    if isinstance(v, str):
+        return (v,) if v else ()
+    if not isinstance(v, (list, tuple)):
+        raise ConfigError("train.stop_sequences must be a string or a list of strings")
+    for s in v:
+        if not isinstance(s, str):
+            raise ConfigError("train.stop_sequences entries must be strings")
+    return tuple(s for s in v if s)
+
+
+class ConfigError(ValueError):
+    pass
+
+
+def _require_slug(value: str, message: str) -> None:
+    """Require a Prime Hub-style "owner/name" slug: exactly one slash, both parts
+    non-empty. Raises ConfigError(message) otherwise. Centralizes the rule used for
+    [environment] id, eval_env_id, and train.hf_repo so they cannot drift apart."""
+    parts = value.split("/")
+    if len(parts) != 2 or not all(parts):
+        raise ConfigError(message)
+
+
+def load_toml(path: str) -> dict[str, Any]:
+    with open(path, "rb") as f:
+        return tomllib.load(f)
+
+
+def spec_from_file(
+    path: str,
+    run_id: str | None = None,
+    overrides: list[str] | None = None,
+    extra_configs: list[str] | None = None,
+) -> JobSpec:
+    raw = load_toml(path)
+    # Composed configs: later files override earlier keys (deep merge).
+    for extra in extra_configs or []:
+        _deep_merge(raw, load_toml(extra))
+    # `--set key=value` dotted overrides (highest precedence).
+    for item in overrides or []:
+        _apply_override(raw, item)
+    return spec_from_dict(raw, run_id=run_id)
+
+
+def _deep_merge(base: dict, extra: dict) -> dict:
+    for k, v in extra.items():
+        if isinstance(v, dict) and isinstance(base.get(k), dict):
+            _deep_merge(base[k], v)
+        else:
+            base[k] = v
+    return base
+
+
+def _coerce_scalar(value: str):
+    low = value.strip().lower()
+    if low in ("true", "false"):
+        return low == "true"
+    try:
+        return int(value)
+    except ValueError:
+        pass
+    try:
+        return float(value)
+    except ValueError:
+        return value
+
+
+def _apply_override(raw: dict, item: str) -> None:
+    if "=" not in item:
+        raise ConfigError(f"--set must be key=value, got {item!r}")
+    key, value = item.split("=", 1)
+    parts = key.strip().split(".")
+    node = raw
+    for p in parts[:-1]:
+        node = node.setdefault(p, {})
+        if not isinstance(node, dict):
+            raise ConfigError(f"--set path {key!r} traverses a non-table value")
+    leaf = parts[-1]
+    # support list values like seeds=[0,1]
+    val = value.strip()
+    if val.startswith("[") and val.endswith("]"):
+        inner = val[1:-1].strip()
+        node[leaf] = [_coerce_scalar(x.strip()) for x in inner.split(",") if x.strip()]
+    else:
+        node[leaf] = _coerce_scalar(val)
+
+
+def spec_from_dict(raw: dict[str, Any], run_id: str | None = None) -> JobSpec:
+    try:
+        model = raw["model"]
+    except KeyError as exc:
+        raise ConfigError("config must set `model`") from exc
+
+    try:
+        algorithm = normalize_algorithm(raw.get("algorithm"))
+    except ValueError as exc:
+        raise ConfigError(str(exc)) from exc
+    model_policy = (raw.get("model_policy") or "catalog").lower()
+    if model_policy not in ("catalog", "allow"):
+        raise ConfigError('model_policy must be "catalog" or "allow"')
+    thinking = raw.get("thinking", False)  # reasoning mode OFF by default (operator preference)
+    if not isinstance(thinking, bool):
+        raise ConfigError("thinking must be a boolean")
+
+    env_raw = raw.get("environment") or {}
+    if not isinstance(env_raw, dict):
+        raise ConfigError("[environment] must be a table")
+    # Local environment paths are gone: a run names a published Hub env by [environment] id.
+    # A stray `path` (alone or alongside `id`) is a stale config — reject it loudly instead of
+    # silently ignoring the key and training against the wrong/missing env.
+    if env_raw.get("path"):
+        raise ConfigError(
+            "local environment paths are no longer supported — remove `path` and reference a "
+            'published Hub `id` ("owner/name")'
+        )
+    train_raw = raw.get("train") or {}
+    gpu_raw = raw.get("gpu") or {}
+
+    # Smart allocation is the default: an omitted gpu.type means "the cheapest GPU
+    # (across providers) that fits the model", re-resolved live at submit time. The
+    # original request survives in gpu.requested so the runner knows whether
+    # it may re-allocate (policy words) or must honor a concrete pin.
+    requested_gpu = str(gpu_raw.get("requested") or gpu_raw.get("type") or "auto")
+    provider = str(gpu_raw.get("provider") or "auto").strip().lower()
+    if provider not in ("auto", *PROVIDER_NAMES):
+        allowed = '", "'.join(("auto", *PROVIDER_NAMES))
+        raise ConfigError(f'gpu.provider must be "{allowed}"')
+    allow_unval = gpu_raw.get("allow_unvalidated")
+    if allow_unval is not None and not isinstance(allow_unval, bool):
+        raise ConfigError("gpu.allow_unvalidated must be a boolean")
+    try:
+        # Parse-time provisional: "cheapest"/"auto" resolve to the cheapest validated
+        # GPU class that fits (across providers, deterministic offline; open models
+        # sized from HF metadata); concrete names are canonicalized. The submit-time
+        # allocator re-resolves policy words live across providers.
+        gpu_type = resolve_gpu_policy(
+            requested_gpu,
+            model,
+            allow_unvalidated=allow_unval,
+            algorithm=algorithm,
+            train=train_raw,
+            thinking=thinking,
+        )
+    except UnsupportedGpuError as exc:
+        raise ConfigError(str(exc)) from exc
+    pinned = requested_gpu.strip().lower() not in POLICY_NAMES
+    if pinned and provider != "auto" and provider not in providers_for(gpu_type):
+        raise ConfigError(
+            f"gpu type {gpu_type!r} is not available on provider {provider!r} "
+            f"(providers: {', '.join(providers_for(gpu_type))})"
+        )
+    if (
+        pinned
+        and not is_validated(gpu_type, provider if provider != "auto" else None)
+        and not unvalidated_allowed(allow_unval)
+    ):
+        raise ConfigError(
+            f"gpu type {gpu_type!r} has not passed AutoSLM's live validation smoke"
+            f"{' on ' + provider if provider != 'auto' else ''} "
+            f"(validated: {', '.join(SUPPORTED)}). Set gpu.allow_unvalidated = true "
+            f"(or AUTOSLM_GPU_ALLOW_UNVALIDATED=1) to use it anyway."
+        )
+    try:
+        info = resolve_model(model, algorithm, policy=model_policy, gpu=gpu_type)
+    except ValueError as exc:
+        raise ConfigError(str(exc)) from exc
+    if thinking and info.thinking == "none":
+        raise ConfigError(
+            f"{model} does not support thinking mode (its chat template has no "
+            f"<think> support); pick a thinking-capable model — `slm models` lists "
+            f"each model's thinking capability"
+        )
+    if not thinking and info.thinking == "always":
+        raise ConfigError(
+            f"{model} always emits <think> reasoning and cannot run with thinking "
+            f"disabled; set thinking = true"
+        )
+    if thinking and info.thinking == "unknown":
+        print(
+            f"warning: open-model policy: cannot verify that {model}'s chat template "
+            f"supports thinking mode; the run proceeds with enable_thinking=true"
+        )
+
+    spec = JobSpec(
+        model=model,
+        algorithm=algorithm,
+        environment=EnvironmentSpec(
+            id=str(env_raw.get("id") or ""),
+            params=dict(env_raw.get("params") or {}),
+            pip=tuple(str(p) for p in env_raw.get("pip") or ()),
+        ),
+        train=TrainSpec(
+            steps=_train_int(train_raw, "steps", minimum=1),
+            epochs=_train_int(train_raw, "epochs", minimum=1),
+            lora_rank=_train_int(train_raw, "lora_rank", minimum=1) or 32,
+            lora_alpha=_train_int(train_raw, "lora_alpha", minimum=1) or 64,
+            seeds=tuple(int(s) for s in train_raw.get("seeds", (0,))),
+            init_from_adapter=str(train_raw.get("init_from_adapter") or ""),
+            hf_repo=str(train_raw.get("hf_repo") or ""),
+            learning_rate=_train_float(train_raw, "learning_rate", minimum=0.0, exclusive=True),
+            batch_size=_train_int(train_raw, "batch_size", minimum=1),
+            max_length=_train_int(train_raw, "max_length", minimum=1),
+            save_every=_train_int(train_raw, "save_every", minimum=1),
+            group_size=_train_int(train_raw, "group_size", minimum=1),
+            temperature=_train_float(train_raw, "temperature", minimum=0.0),
+            max_tokens=_train_int(train_raw, "max_tokens", minimum=1),
+            kl_penalty_coef=_train_float(train_raw, "kl_penalty_coef", minimum=0.0),
+            advantage_clip=_train_float(train_raw, "advantage_clip", minimum=0.0),
+            thinking_length_penalty_coef=_train_float(
+                train_raw, "thinking_length_penalty_coef", minimum=0.0, maximum=1.0
+            ),
+            stop_sequences=_train_stops(train_raw),
+            # GPUs in the node dedicated to the disaggregated vLLM rollout server (0 = colocate,
+            # the default). >0 needs a multi-GPU node ([gpu] count = trainer + inference); the
+            # count>inference_gpus cross-check is in _validate_spec. minimum=0 so an explicit
+            # `inference_gpus = 0` (colocate) is accepted, not rejected as below-minimum.
+            inference_gpus=_train_int(train_raw, "inference_gpus", minimum=0) or 0,
+        ),
+        gpu=GpuSpec(
+            type=gpu_type,
+            count=int(gpu_raw.get("count", 1)),
+            provider=provider,
+            requested=requested_gpu,
+            allow_unvalidated=allow_unval,
+            disk_gb=int(gpu_raw.get("disk_gb", 60)),
+            max_wall_seconds=int(gpu_raw.get("max_wall_seconds", 24 * 3600)),
+            max_retries=int(gpu_raw.get("max_retries", 2)),
+            network_volume=gpu_raw.get("network_volume"),
+            network_volume_gb=int(gpu_raw.get("network_volume_gb", 100)),
+            datacenter=gpu_raw.get("datacenter"),
+        ),
+        run_id=run_id or raw.get("run_id", "local"),
+        worker_env=_worker_env(raw.get("worker_env")),
+        model_policy=model_policy,
+        thinking=thinking,
+    )
+    _validate_spec(spec)
+    return spec
+
+
+def _worker_env(raw: Any) -> dict[str, str]:
+    """Parse the optional [worker_env] table: per-run worker env overrides (string-valued)."""
+    if raw is None:
+        return {}
+    if not isinstance(raw, dict):
+        raise ConfigError("[worker_env] must be a table of string key/values")
+    env = {str(k): str(v) for k, v in raw.items()}
+    # [worker_env] is serialized into job_spec_json (persisted + logged), so it must NOT carry
+    # secrets — they would leak into run artifacts. Reject secret-looking keys; operators set
+    # those as real process environment variables (forwarded to the worker out-of-band) instead.
+    # Detect by `_`-delimited WORD components (not substring): flag a secret WORD, or `KEY`
+    # qualified by API/SECRET/PRIVATE/ACCESS/INTERNAL/AUTH. This catches HF_TOKEN, *_API_KEY,
+    # SECRET_KEY, INTERNAL_KEY, CREDENTIAL, AWS_SECRET_ACCESS_KEY while allowing legit knobs whose
+    # names merely contain a marker (RL_VLLM_MAX_BATCHED_TOKENS -> word TOKENS, not TOKEN; a bare
+    # SORT_KEY -> KEY without a secret qualifier).
+    _secret_words = {"TOKEN", "SECRET", "PASSWORD", "PASSWD", "CREDENTIAL", "CREDENTIALS", "APIKEY", "PRIVATEKEY"}
+    _key_qualifiers = {"API", "SECRET", "PRIVATE", "ACCESS", "INTERNAL", "AUTH", "SIGNING", "ENCRYPTION"}
+
+    def _is_secret_key(name: str) -> bool:
+        words = set(name.upper().split("_"))
+        return bool(words & _secret_words) or ("KEY" in words and bool(words & _key_qualifiers))
+
+    secrets = sorted(k for k in env if _is_secret_key(k))
+    if secrets:
+        raise ConfigError(
+            f"[worker_env] must not contain secret-bearing keys ({', '.join(secrets)}); these are "
+            "serialized into run artifacts — set them as real environment variables instead"
+        )
+    return env
+
+
+def _validate_spec(spec: JobSpec) -> None:
+    if not spec.train.seeds:
+        raise ConfigError("train.seeds must contain at least one seed")
+    try:
+        canonical_gpu(spec.gpu.type)
+    except UnsupportedGpuError as exc:
+        raise ConfigError(str(exc)) from exc
+    # GRPO is step-driven; SFT is epoch-driven. Reject a non-positive explicit count
+    # for whichever the algorithm consumes, so an invalid config fails here instead of
+    # provisioning a worker that silently falls back to a default count.
+    if spec.algorithm == "grpo" and spec.train.steps is not None and spec.train.steps <= 0:
+        raise ConfigError("train.steps must be positive for GRPO")
+    if spec.algorithm == "sft" and spec.train.epochs is not None and spec.train.epochs <= 0:
+        raise ConfigError("train.epochs must be positive for SFT")
+    # Verifiers-only: every run must name an environment by its verifiers/Prime Hub slug
+    # via [environment] id. There is no default environment and no local path mode.
+    if not spec.environment.id:
+        raise ConfigError(
+            "config must set [environment] id (a verifiers/Prime Hub env slug, e.g. "
+            '"owner/name"); there is no local path mode'
+        )
+    # The id must be a full Prime Hub slug "owner/name": exactly one slash, both parts
+    # non-empty. A bare id like "gsm8k" passes the presence check but then the worker runs
+    # `prime env install gsm8k` (invalid — Prime needs owner/name) and fails after provisioning.
+    _require_slug(
+        spec.environment.id,
+        '[environment] id must be a published Prime Hub slug "owner/name"',
+    )
+    # A separate eval env ([environment.params] eval_env_id) is also prime-installed on the worker
+    # (worker_hub_env_ids), so it must be a full "owner/name" slug too — else a bare eval id passes
+    # --dry-run but fails `prime env install` after a GPU is provisioned.
+    if "eval_env" in spec.environment.params:
+        # Legacy alias: `eval_env` is no longer mapped (the worker installs only eval_env_id, and
+        # a stray `eval_env` would be forwarded into load_environment). Reject at parse rather than
+        # silently evaluating against the training env.
+        raise ConfigError(
+            "[environment.params] eval_env is no longer supported; use eval_env_id "
+            '(a published Prime Hub slug "owner/name")'
+        )
+    eval_ref = spec.environment.params.get("eval_env_id")
+    if eval_ref:
+        _require_slug(
+            str(eval_ref),
+            '[environment.params] eval_env_id must be a published Prime Hub slug "owner/name"',
+        )
+    if spec.train.lora_rank <= 0:
+        raise ConfigError("train.lora_rank must be positive")
+    # The per-run HF artifact repo (adapters/checkpoints/code + serving) is required: there
+    # is no operator-wide default anymore. It must look like "owner/name" (exactly one slash,
+    # both parts non-empty) — a malformed value would reach the worker/serve as an unusable id.
+    if not spec.train.hf_repo:
+        raise ConfigError(
+            "train.hf_repo is required: the HF dataset repo for this run's adapters/checkpoints, "
+            'e.g. "owner/name"'
+        )
+    _require_slug(
+        spec.train.hf_repo,
+        'train.hf_repo must be a HuggingFace repo of the form "owner/name"',
+    )
+    # GRPO recipe knobs (group_size/temperature/max_tokens/kl_penalty_coef/advantage_clip/
+    # thinking_length_penalty_coef) are range-validated at parse time by the _train_int/
+    # _train_float coercers above (including the thinking_length_penalty_coef <= 1.0 upper
+    # bound), so no re-check is needed here.
+    # lora_alpha scales the adapter contribution; 0 (or negative) trains a paid run
+    # that produces a no-op adapter (zero scaling at serve). Reject up front.
+    if spec.train.lora_alpha <= 0:
+        raise ConfigError("train.lora_alpha must be positive")
+    # Multi-GPU / disaggregated-rollout topology ([gpu] count, [train] inference_gpus).
+    if spec.gpu.count < 1:
+        raise ConfigError("gpu.count must be >= 1")
+    if spec.train.inference_gpus < 0:
+        raise ConfigError("train.inference_gpus must be >= 0")
+    if spec.train.inference_gpus > 0:
+        # The disaggregated async rollout (vLLM server on dedicated GPUs) is a GRPO-only path —
+        # SFT has no rollout engine, so inference_gpus would just strand paid GPUs.
+        if spec.algorithm != "grpo":
+            raise ConfigError(
+                "train.inference_gpus is only valid for grpo (the disaggregated rollout server); "
+                "SFT has no rollout engine"
+            )
+        # Need at least one trainer GPU left after carving off the inference GPUs.
+        if spec.gpu.count <= spec.train.inference_gpus:
+            raise ConfigError(
+                f"gpu.count ({spec.gpu.count}) must be greater than train.inference_gpus "
+                f"({spec.train.inference_gpus}) — at least one GPU must train "
+                "(gpu.count = trainer GPUs + inference_gpus)"
+            )
+        # train_gpus>1 (2:1, 3:1, 2:2) runs the trainer as an FSDP group via `accelerate launch`
+        # (run_rl's disaggregated launcher re-execs the worker across the train devices). Supported.