Upload folder using huggingface_hub

code/flash/__init__.py

@@ -0,0 +1,11 @@
+"""Flash — 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/flash/_fileio.py

@@ -0,0 +1,35 @@
+"""Small shared file-IO helpers for credential/manifest JSON under ``~/.flash``."""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+from pathlib import Path
+
+
+def read_json_or_empty(path: Path) -> dict:
+    """Parse a JSON object file, returning ``{}`` if it's missing or unreadable."""
+    try:
+        return json.loads(path.read_text())
+    except (OSError, ValueError):
+        return {}
+
+
+def secure_json_write(path: Path, data: dict) -> None:
+    """Write ``data`` as JSON with private permissions (the file may hold a secret).
+
+    Creates the parent dir (0700) and opens the file 0600 from the start — never
+    write_text + chmod, which leaves it umask-readable in between. ``O_NOFOLLOW``
+    (where available) refuses to follow a symlink planted at ``path`` so the write
+    can't be redirected to clobber an arbitrary file.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with contextlib.suppress(OSError):
+        os.chmod(path.parent, 0o700)
+    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC | getattr(os, "O_NOFOLLOW", 0)
+    fd = os.open(path, flags, 0o600)
+    with os.fdopen(fd, "w") as f:
+        json.dump(data, f, indent=2, sort_keys=True)
+    with contextlib.suppress(OSError):
+        os.chmod(path, 0o600)

code/flash/_logging.py

@@ -0,0 +1,49 @@
+"""Package logging helpers.
+
+Library code logs through the ``flash`` logger and never configures handlers on import (it
+attaches a :class:`logging.NullHandler`), so importing Flash stays silent for downstream
+applications. The CLI calls :func:`configure_logging` to attach a console handler whose
+level is controlled by ``-v/--verbose``.
+"""
+
+from __future__ import annotations
+
+import logging
+
+_ROOT_NAME = "flash"
+
+# 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 ``flash`` 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 configure_logging(verbosity: int = 0, level: int | None = None) -> None:
+    """Attach a console handler to the ``flash`` logger and set its level.
+
+    ``verbosity`` maps repeated ``-v`` flags to levels (0=WARNING, 1=INFO, >=2=DEBUG).
+    An explicit ``level`` overrides the verbosity mapping.
+    """
+    if level is None:
+        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, "_flash_console", False)]:
+        logger.removeHandler(h)
+    handler = logging.StreamHandler()  # stderr
+    handler.setLevel(level)
+    handler.setFormatter(logging.Formatter("%(levelname)s %(name)s: %(message)s"))
+    handler._flash_console = True  # type: ignore[attr-defined]
+    logger.addHandler(handler)

code/flash/catalog.py

@@ -0,0 +1,219 @@
+"""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"
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+# The default model Flash 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 flash.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.",
+    ),
+}
+
+
+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 flash.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/flash/cli/__init__.py

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

code/flash/cli/main.py

@@ -0,0 +1,919 @@
+"""CLI for the managed Flash service.
+
+Every run-lifecycle command is a thin HTTP call to the Flash 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 flash import __version__
+from flash._logging import configure_logging, get_logger
+from flash.catalog import public_model_rows
+from flash.client import (
+    ApiClient,
+    ClientError,
+    client_from_config,
+    save_credentials,
+    verify_freesolo_key,
+)
+from flash.client.config import load_credentials
+from flash.client.specs import spec_payload
+from flash.runner import TERMINAL_STATES, new_run_id
+from flash.schema import ConfigError, spec_from_file
+
+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 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",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="increase log verbosity (-v for info, -vv for debug)",
+    )
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    version = sub.add_parser("version", help="print the Flash 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="flash control-plane URL for training calls (default: FLASH_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
+    # `flash-server` console script (flash.server.__main__:main), not a `slm` subcommand.
+
+    args = parser.parse_args(argv)
+    configure_logging(verbosity=getattr(args, "verbose", 0))
+    debug = getattr(args, "debug", False)
+    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 flash 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 flash'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 flash.providers import available_providers
+    from flash.providers.base import GPU_INFO
+    from flash.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 flash.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 Flash.\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 flash.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/flash-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 flash.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 ~/.flash/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 — flash 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 ~/.flash/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 = "Flash 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 "flash-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 flash.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 flash configs
+    (``flash_grpo.toml``/``flash_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 ("flash_grpo.toml", "flash_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 _flash_os, sys as _flash_sys\n"
+        "_flash_sys.path.insert(0, _flash_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 flash 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\nFlash 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/flash/client/__init__.py

@@ -0,0 +1,14 @@
+"""HTTP client for the managed Flash 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/flash/client/config.py

@@ -0,0 +1,46 @@
+"""Client-side credential storage: the Flash API key + control-plane URL.
+
+Stored in ``~/.flash/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, ``FLASH_API_URL`` for the URL.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .._fileio import read_json_or_empty, secure_json_write
+
+DEFAULT_API_URL = "https://flash.freesolo.co"
+
+CONFIG_DIR = Path.home() / ".flash"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+
+
+def _read_config() -> dict:
+    return read_json_or_empty(CONFIG_PATH)
+
+
+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("FLASH_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 FLASH_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("/")
+    secure_json_write(CONFIG_PATH, cfg)
+    return CONFIG_PATH

code/flash/client/http.py

@@ -0,0 +1,187 @@
+"""Stdlib HTTP client for the Flash 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 flash control plane): `slm login`
+# verifies the user's freesolo API key here. The same key authenticates the flash
+# 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 Flash service at {self.api_url} ({exc.reason}); "
+                "check your network connection and FLASH_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/flash/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 ``~/.flash/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 flash.spec import JobSpec
+
+
+def spec_payload(spec: JobSpec) -> dict:
+    out = spec.to_dict()
+    if not spec.environment.pip:
+        from flash.envs.registry import worker_pip_for_env
+
+        pip = worker_pip_for_env(spec.environment.id)
+        if pip:
+            out["environment"]["pip"] = pip
+    return out

code/flash/engine/__init__.py

@@ -0,0 +1,7 @@
+"""Substrate-neutral fine-tuning internals for the Flash 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 ``flash.providers.runpod`` invokes ``flash.engine.worker`` on the
+provisioned GPU.
+"""

code/flash/engine/accounting.py

@@ -0,0 +1,37 @@
+"""Cost accounting + the standard run-metrics record for Flash 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/flash/engine/chalk_kernels.py

@@ -0,0 +1,162 @@
+"""Optional chalk GPU kernels (the ``freesolo-chalk`` package).
+
+Chalk holds Freesolo's hand-written Triton/CUDA kernels that complement Liger
+(fused GEMMs, the LoRA-delta matmuls, the QKV norm+RoPE epilogue, embedding gather,
+FP8 frozen-base GEMMs).
+
+Chalk follows the **install-on-call** model (mirroring Liger's
+``apply_liger_kernel_to_qwen3``): chalk reads NO env vars — *calling* an installer IS
+the opt-in. Each installer then arch-gates itself, runs a numeric self-test on install,
+patches only frozen ``nn.Linear`` layers, and silently falls back to the eager / Liger
+path (a no-op on CPU / the control plane) on any failure.
+
+Because chalk no longer gates itself, the FLASH WORKER must decide *which* installers to
+call. :func:`install_chalk_kernels` reads per-kernel ``FLASH_*`` selection flags (set by
+the operator, forwarded to the worker by ``providers.runpod.train.build_worker_env``) and
+calls ONLY the selected chalk installers. With NO flags set (the default) it calls
+nothing, so it is always safe to invoke; and if ``freesolo-chalk`` isn't installed at all
+(e.g. on the control plane, or a worker without a chalk spec) the whole module degrades to
+a no-op.
+"""
+
+from __future__ import annotations
+
+import os
+
+from flash._logging import get_logger
+
+log = get_logger(__name__)
+
+
+def _truthy(name: str) -> bool:
+    """A FLASH_* flag counts as ON when set to a non-empty, non-false value."""
+    v = os.environ.get(name)
+    return v is not None and v.strip().lower() not in ("", "0", "false", "no", "off")
+
+
+def _int_env(name: str, default: int) -> int:
+    raw = os.environ.get(name)
+    if raw is None or not raw.strip():
+        return default
+    try:
+        return int(raw.strip())
+    except ValueError:
+        log.warning("ignoring non-integer %s=%r (using %d)", name, raw, default)
+        return default
+
+
+def _selected_installers() -> list[tuple[str, bool, dict]]:
+    """The chalk installers the operator selected via ``FLASH_*`` flags.
+
+    Returns ``(installer_name, needs_model, kwargs)`` for each ENABLED kernel. ``needs_model``
+    marks the instance-level installers (they patch the materialized ``nn.Module`` and must be
+    skipped when no model is available yet); the class/function-level ones install with no model.
+
+    Default (no flags set) is an empty list -> :func:`install_chalk_kernels` calls nothing.
+    """
+    selected: list[tuple[str, bool, dict]] = []
+    # Class/function-level kernels (patch the model class / a global fn; no model arg needed).
+    # chalk signatures: install_qwen35_mlp(model=None), install_qwen35_qkv(model=None),
+    # install_lora() [no model param], install_qwen35_rope() [no model param].
+    if _truthy("FLASH_MLP_KERNEL"):
+        selected.append(("install_qwen35_mlp", False, {}))
+    if _truthy("FLASH_QKV_KERNEL"):
+        selected.append(("install_qwen35_qkv", False, {}))
+    if _truthy("FLASH_TRITON_LORA"):
+        selected.append(("install_lora", False, {}))
+    if _truthy("FLASH_ROPE_KERNEL"):
+        selected.append(("install_qwen35_rope", False, {}))
+    # Instance-level kernels (need the built nn.Module).
+    # chalk signatures: install_qwen35_mlp_fp8(model, *, down=True),
+    # install_fp8_base(model, *, attn=True, mlp=True, min_k=256),
+    # install_qwen35_embedding(model).
+    if _truthy("FLASH_MLP_FP8"):
+        # FLASH_MLP_FP8_DOWN selects whether the down-projection is fused too (chalk default True).
+        down = os.environ.get("FLASH_MLP_FP8_DOWN")
+        kwargs = {} if down is None else {"down": _truthy("FLASH_MLP_FP8_DOWN")}
+        selected.append(("install_qwen35_mlp_fp8", True, kwargs))
+    if _truthy("FLASH_FP8_BASE"):
+        # Per-kernel scope knobs mirror chalk's install_fp8_base kwargs; only forward the ones the
+        # operator set so chalk's own defaults (attn=True, mlp=True, min_k=256) apply otherwise.
+        kwargs = {}
+        if os.environ.get("FLASH_FP8_BASE_ATTN") is not None:
+            kwargs["attn"] = _truthy("FLASH_FP8_BASE_ATTN")
+        if os.environ.get("FLASH_FP8_BASE_MLP") is not None:
+            kwargs["mlp"] = _truthy("FLASH_FP8_BASE_MLP")
+        if os.environ.get("FLASH_FP8_BASE_MIN_K") is not None:
+            kwargs["min_k"] = _int_env("FLASH_FP8_BASE_MIN_K", 256)
+        selected.append(("install_fp8_base", True, kwargs))
+    if _truthy("FLASH_EMBED_KERNEL"):
+        selected.append(("install_qwen35_embedding", True, {}))
+    return selected
+
+
+def install_chalk_kernels(model=None) -> dict:
+    """Install the chalk kernels the operator selected via ``FLASH_*`` flags.
+
+    chalk reads NO env vars (install-on-call), so the WORKER decides which installers to call:
+    each enabled ``FLASH_*`` flag maps to one chalk installer (see :func:`_selected_installers`).
+    With no flags set this calls nothing and returns ``{}``.
+
+    Call this TWICE per training run — exactly the two passes the worker makes — and each kernel
+    installs on the ONE pass it belongs to (never twice):
+
+    * ``install_chalk_kernels()`` (``model is None``, the PRE-build pass) installs only the
+      class/function-level kernels (LoRA delta, fused MLP/QKV, RoPE) — global monkeypatches that
+      must be in place before the trainer builds the model. Instance-level kernels are skipped (no
+      module yet).
+    * ``install_chalk_kernels(trainer.model)`` (``model is not None``, the POST-build pass) installs
+      only the instance-level kernels (FP8 base, embedding, FP8 MLP) against the materialized
+      module. The class/function-level monkeypatches were already applied on the pre-build pass, so
+      re-running them here would double-patch — they are deliberately NOT re-run.
+
+    Returns a ``{installer_name: result}`` map for the installers that ran ON THIS PASS (``{}`` when
+    no flag is set, chalk isn't installed, or no selected kernel belongs to this pass).
+    """
+    selected = _selected_installers()
+    if not selected:
+        # No FLASH_* kernel flag set -> the operator opted into nothing. Don't even import chalk.
+        return {}
+
+    try:
+        import chalk.transformers as ck
+    except ImportError:
+        # A FLASH_* flag is set but chalk isn't installed (control plane, or a worker without a
+        # chalk spec in FLASH_CHALK_SPEC/extra_pip). Documented as always safe — warn and no-op.
+        log.warning(
+            "FLASH_* chalk kernel(s) requested but freesolo-chalk is not installed "
+            "(set FLASH_CHALK_SPEC to an installable spec on the worker); skipping."
+        )
+        return {}
+    except Exception as e:
+        # A partially-installed / version-incompatible chalk can raise non-ImportError errors at
+        # import time (e.g. a Triton/torch mismatch surfaced on import of a kernel module). This
+        # hook is documented as always safe and must never abort training, so degrade to a no-op.
+        log.warning("chalk import failed (ignored, kernels disabled): %s", e)
+        return {}
+
+    results: dict[str, object] = {}
+    for name, needs_model, kwargs in selected:
+        # Each kernel installs on exactly ONE of the two passes, so the second call never
+        # re-applies what the first already installed:
+        #   * class/function-level (needs_model=False): global monkeypatches -> PRE-build pass only
+        #     (model is None). Skipping them when a model is present avoids re-installing the global
+        #     patch the pre-build call already applied (double-patch).
+        #   * instance-level (needs_model=True): patch the built nn.Module -> POST-build pass only
+        #     (model is not None); there is no module to patch on the pre-build pass.
+        if needs_model != (model is not None):
+            continue
+        fn = getattr(ck, name, None)
+        if fn is None:
+            log.warning("chalk has no installer %s (skipping)", name)
+            continue
+        try:
+            results[name] = fn(model, **kwargs) if needs_model else fn(**kwargs)
+        except Exception as e:  # never block training on an optional kernel
+            log.warning("chalk %s failed (ignored): %s", name, e)
+            results[name] = f"error: {e}"
+
+    enabled = {k: v for k, v in results.items() if v not in (False, None) and not str(v).startswith("error")}
+    if enabled:
+        log.info("chalk kernels active: %s", ", ".join(enabled))
+    return results

code/flash/engine/midrun_eval.py

@@ -0,0 +1,446 @@
+"""Periodic mid-run evaluation for GRPO (greedy eval on a held-out split, between steps).
+
+GRPO's only live signal is the per-step *training* reward — noisy, on-policy, temperature>0,
+and (by design) often a SHAPED reward rather than the metric you actually care about. This
+module adds a deterministic eval signal: every ``N`` optimizer steps it samples the current
+policy GREEDILY on a fixed held-out split and scores it, then streams the result through the
+worker ``heartbeat`` so the orchestrating agent sees an eval curve mid-run (early-stop, plateau
+detection, checkpoint selection) instead of only the reward stream.
+
+Evaluation distinct from reward lives in the environment. A verifiers
+``environment.py`` expresses an evaluation metric SEPARATE from the GRPO reward as a
+**eval-metric rubric func** (``rubric.add_metric(fn, weight=0.0)``): it does not shape training
+but is computed and reported. The adapter's :meth:`VerifiersEnvironment.evaluate` returns both
+the weighted training ``reward`` and those eval-metric ``metrics`` in one rubric pass, and this
+module surfaces both — so the agent watches the env's true eval metric, not just the reward.
+
+It generates with the **trainer's own model** (``trainer.model.generate`` in eval/no-grad mode),
+NOT the colocate vLLM engine. Calling ``engine.generate`` out-of-band from a ``TrainerCallback``
+deadlocks GRPO (the engine is only safe to drive inside TRL's managed ``rollout_func`` window;
+an external call from ``on_step_end`` hangs the training thread — verified on a live GPU run).
+Generating on the already-loaded trainer model avoids the engine entirely, works on BOTH the
+vLLM-colocate and transformers-generation backends, and keeps memory bounded: ONE prompt at a
+time (a single sequence's KV cache), and an OOM there is a *catchable* error -> graceful
+``eval_skipped``, never a training-freezing hang.
+
+Design mirrors :mod:`flash.engine.multiturn_rollout`: the core (:class:`PeriodicEval`, the
+scorers, :func:`evaluate_policy`, :func:`summarize`) is pure Python with ``render`` / ``generate``
+/ engine access INJECTED, so cadence gating, engine binding, skip handling and heartbeat
+emission are unit-tested without a GPU, tokenizer, or vLLM. Only :func:`build_hf_greedy_generate`
+(wired in ``worker.run_rl``) touches torch / the live model.
+"""
+
+from __future__ import annotations
+
+import random
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+from flash.engine.multiturn_rollout import rollout_one
+
+# A failed single rollout (template violation, env exception) scores 0 rather than crashing the
+# whole eval — and a crashing eval must never abort a paid training run, so the callback also
+# swallows eval-wide failures and heartbeats a skip reason.
+_EVAL_ERROR_REWARD = 0.0
+
+
+@dataclass(frozen=True)
+class EvalRecord:
+    """One example's eval result: the training ``reward`` and the env's eval-metric ``metrics``."""
+
+    reward: float
+    metrics: dict[str, float] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class EvalSummary:
+    """Aggregate of one mid-run eval pass over the held-out set."""
+
+    n: int
+    mean_reward: float
+    pass_rate: float
+    min_reward: float
+    max_reward: float
+    metric_means: dict[str, float] = field(default_factory=dict)
+    rewards: list[float] = field(default_factory=list)
+    step: int | None = None
+
+    def as_heartbeat_fields(self) -> dict:
+        """The flat fields streamed under the ``rl_eval`` heartbeat stage. Each env eval metric
+        is reported as ``eval_metric_<name>`` so it sits alongside the reward, distinct from it."""
+        fields: dict[str, float | int] = {
+            "eval_n": self.n,
+            "eval_reward": self.mean_reward,
+            "eval_pass_rate": self.pass_rate,
+            "eval_reward_min": self.min_reward,
+            "eval_reward_max": self.max_reward,
+        }
+        for name, value in self.metric_means.items():
+            fields[f"eval_metric_{name}"] = value
+        return fields
+
+    def as_record(self) -> dict:
+        """A compact per-eval record for the run's ``metrics.json`` ``notes['eval_history']`` —
+        what the orchestrating agent reads post-run to judge the model on the EVAL metric, not
+        just the training reward. Drops the per-example list to keep metrics.json small."""
+        return {
+            "step": self.step,
+            "eval_reward": self.mean_reward,
+            "eval_pass_rate": self.pass_rate,
+            "eval_n": self.n,
+            "eval_metrics": dict(self.metric_means),
+        }
+
+
+def summarize(
+    records: list[EvalRecord], *, step: int | None = None, pass_threshold: float = 0.5
+) -> EvalSummary:
+    """Reduce per-example records to an :class:`EvalSummary` (empty -> all-zero, n=0).
+
+    ``pass_rate`` is the fraction with training ``reward >= pass_threshold``; each env metric is
+    averaged independently across the examples that reported it.
+    """
+    if not records:
+        return EvalSummary(0, 0.0, 0.0, 0.0, 0.0, {}, [], step)
+    rewards = [float(r.reward) for r in records]
+    n = len(rewards)
+    metric_sums: dict[str, float] = {}
+    metric_counts: dict[str, int] = {}
+    for rec in records:
+        for name, value in rec.metrics.items():
+            metric_sums[name] = metric_sums.get(name, 0.0) + float(value)
+            metric_counts[name] = metric_counts.get(name, 0) + 1
+    metric_means = {name: metric_sums[name] / metric_counts[name] for name in metric_sums}
+    return EvalSummary(
+        n=n,
+        mean_reward=sum(rewards) / n,
+        pass_rate=sum(1 for r in rewards if r >= pass_threshold) / n,
+        min_reward=min(rewards),
+        max_reward=max(rewards),
+        metric_means=metric_means,
+        rewards=rewards,
+        step=step,
+    )
+
+
+def evaluate_policy(
+    examples: list[dict],
+    score_one: Callable[[dict], EvalRecord],
+    *,
+    step: int | None = None,
+    pass_threshold: float = 0.5,
+    on_error: str = "zero",
+    on_warn: Callable[[str], None] | None = None,
+) -> EvalSummary:
+    """Score every example with ``score_one`` and summarize.
+
+    ``on_error="zero"`` (default) makes a per-example scoring failure a zero-reward record (so
+    one bad rollout doesn't sink the pass); ``on_error="raise"`` re-raises (tests).
+
+    A SYSTEMIC failure (every example errors — e.g. generation OOMs each call) raises instead of
+    returning ``eval_reward=0``: a flat-zero curve reads as "the model got everything wrong",
+    which is misleading when the eval simply couldn't run. The caller turns that into a skip.
+    """
+    records: list[EvalRecord] = []
+    errors = 0
+    last_error: Exception | None = None
+    for ex in examples:
+        try:
+            records.append(score_one(ex))
+        except Exception as exc:  # a bad rollout must not abort the eval/run
+            if on_error == "raise":
+                raise
+            errors += 1
+            last_error = exc
+            if on_warn:
+                on_warn(f"mid-run eval: example scored 0 after error: {exc}")
+            records.append(EvalRecord(_EVAL_ERROR_REWARD, {}))
+    if examples and errors == len(examples):
+        raise RuntimeError(
+            f"mid-run eval: all {errors} examples failed to generate "
+            f"(last error: {last_error}) — reporting a skip, not eval_reward=0"
+        )
+    return summarize(records, step=step, pass_threshold=pass_threshold)
+
+
+def single_turn_scorer(
+    active_env,
+    render_prompt_ids: Callable[[dict], list[int]],
+    generate: Callable[[list[int], int], tuple[list[int], list[float], str]],
+    max_new_tokens: int,
+    graded_text: Callable[[str | None], str | None] = lambda c: c,
+) -> Callable[[dict], EvalRecord]:
+    """Per-example scorer for a single-turn env: render -> greedy generate -> env evaluate.
+
+    ``generate(prefix_ids, max_tokens) -> (token_ids, logprobs, text)`` mirrors the colocate
+    engine wrapper used by the multi-turn rollout; only ``text`` is used here. ``graded_text``
+    strips ``<think>`` blocks before scoring on thinking runs (worker parity). Uses the env's
+    :meth:`evaluate` so the env's eval-metric metrics come back alongside the reward."""
+
+    def score(example: dict) -> EvalRecord:
+        prefix_ids = render_prompt_ids(example)
+        _ids, _lps, text = generate(prefix_ids, max_new_tokens)
+        result = active_env.evaluate(graded_text(text), example)
+        return EvalRecord(
+            reward=float(result["reward"]),
+            metrics={k: float(v) for k, v in (result.get("metrics") or {}).items()},
+        )
+
+    return score
+
+
+def multi_turn_scorer(
+    active_env,
+    render_messages: Callable[[list, bool], list[int]],
+    generate: Callable[[list[int], int], tuple[list[int], list[float], str]],
+    *,
+    max_turns: int,
+    max_new_tokens: int,
+    engine_max_len: int | None = None,
+    on_warn: Callable[[str], None] | None = None,
+) -> Callable[[dict], EvalRecord]:
+    """Per-example scorer for a multi-turn env: drive the env turn loop GREEDILY via
+    :func:`rollout_one` and read its rubric reward. (Per-metric breakdown for multi-turn is a
+    follow-up — ``rollout_one`` returns only the scalar reward — so ``metrics`` is empty here.)"""
+
+    def score(example: dict) -> EvalRecord:
+        result = rollout_one(
+            example=example,
+            active_env=active_env,
+            render=render_messages,
+            generate=generate,
+            max_turns=max_turns,
+            per_turn_max_tokens=max_new_tokens,
+            engine_max_len=engine_max_len,
+            on_warn=on_warn,
+        )
+        return EvalRecord(reward=float(result["reward"]), metrics={})
+
+    return score
+
+
+class PeriodicEval:
+    """Pure cadence + engine-binding + heartbeat logic for mid-run eval (no GPU/transformers).
+
+    ``score_one_builder(engine) -> score_one`` defers all GPU-specific wiring (the vLLM
+    SamplingParams, the tokenizer render) to call time, so this class is fully unit-testable
+    with a fake engine getter, a fake builder, and a fake heartbeat sink.
+    """
+
+    def __init__(
+        self,
+        *,
+        examples: list[dict],
+        score_one_builder: Callable[[object], Callable[[dict], EvalRecord]],
+        every_steps: int,
+        heartbeat_fn: Callable[..., object],
+        model_getter: Callable[[], object] | None = None,
+        pass_threshold: float = 0.5,
+        label: str = "rl_eval",
+        on_warn: Callable[[str], None] = print,
+    ) -> None:
+        self.examples = list(examples)
+        self.score_one_builder = score_one_builder
+        self.every_steps = int(every_steps)
+        self.heartbeat_fn = heartbeat_fn
+        self.model_getter = model_getter
+        self.pass_threshold = float(pass_threshold)
+        self.label = label
+        self.on_warn = on_warn
+        self._disabled = False
+        # Accumulated eval curve, persisted into metrics.json so the agent reads it post-run.
+        self.history: list[EvalSummary] = []
+
+    def history_records(self) -> list[dict]:
+        """The eval curve as compact dicts for ``metrics.json`` ``notes['eval_history']``."""
+        return [s.as_record() for s in self.history]
+
+    def bind_model_getter(self, getter: Callable[[], object]) -> None:
+        """Attach the (late-bound) accessor for the live generation model — the trainer that owns
+        it does not exist when the callback is constructed."""
+        self.model_getter = getter
+
+    def should_run(self, step: int) -> bool:
+        return (
+            not self._disabled
+            and self.every_steps > 0
+            and step > 0
+            and bool(self.examples)
+            and step % self.every_steps == 0
+        )
+
+    def maybe_run(self, step: int) -> EvalSummary | None:
+        if not self.should_run(step):
+            return None
+        return self.run_eval(step)
+
+    def run_final(self, step: int) -> EvalSummary | None:
+        """Evaluate the FINAL trained policy once, after training ends.
+
+        The cadence (``maybe_run``) only fires on exact multiples of ``every_steps``; when the run
+        length is not a multiple (the common case), the last cadence eval predates the saved
+        adapter. This runs one more eval on the final model so ``eval_history`` ends on the policy
+        that was actually saved — unless the last recorded eval is already this exact step (run
+        length was an exact multiple, so the final step was already evaluated)."""
+        if self._disabled or self.every_steps <= 0 or step <= 0 or not self.examples:
+            return None
+        if self.history and self.history[-1].step == step:
+            return None  # the final step coincided with a cadence eval; don't double-run
+        return self.run_eval(step)
+
+    def run_eval(self, step: int) -> EvalSummary | None:
+        """Evaluate the current policy once and heartbeat the result (or a skip reason).
+
+        Never raises (even if the model getter itself throws): any failure heartbeats a skip
+        reason for THIS step and lets training continue. A missing model only skips this cadence
+        — it does NOT permanently disable eval, since the getter resolves the live model each
+        time and a one-off ``None`` (e.g. a teardown race) can resolve by the next cadence.
+        """
+        try:
+            model = self.model_getter() if self.model_getter is not None else None
+        except Exception as exc:  # the getter (attribute access on the trainer) must not abort
+            self.heartbeat_fn(
+                self.label, step=step, eval_skipped=True, eval_reason=f"model getter failed: {exc}"
+            )
+            return None
+        if model is None:
+            self.heartbeat_fn(
+                self.label, step=step, eval_skipped=True, eval_reason="no model available"
+            )
+            return None
+        try:
+            score_one = self.score_one_builder(model)
+            summary = evaluate_policy(
+                self.examples,
+                score_one,
+                step=step,
+                pass_threshold=self.pass_threshold,
+                on_warn=self.on_warn,
+            )
+        except Exception as exc:  # eval must never abort training
+            self.heartbeat_fn(
+                self.label,
+                step=step,
+                eval_skipped=True,
+                eval_reason=f"{type(exc).__name__}: {exc}",
+            )
+            return None
+        self.history.append(summary)  # accumulate the curve for metrics.json (agent reads it)
+        self.heartbeat_fn(self.label, step=step, **summary.as_heartbeat_fields())
+        return summary
+
+
+def make_periodic_eval_callback(periodic: PeriodicEval):
+    """Wrap a :class:`PeriodicEval` in a transformers ``TrainerCallback`` (lazy import).
+
+    Mirrors ``worker.make_reward_heartbeat_callback``: the callback fires on every optimizer
+    step end and delegates the cadence decision to ``periodic.maybe_run``."""
+    from transformers import TrainerCallback
+
+    class _PeriodicEvalCallback(TrainerCallback):
+        def on_step_end(self, args, state, control, **kwargs):
+            step = int(getattr(state, "global_step", 0) or 0)
+            periodic.maybe_run(step)
+
+    return _PeriodicEvalCallback()
+
+
+# ---------------------------------------------------------------------------
+# GPU-side wiring (the only part that touches torch / the model). From worker.run_rl.
+# ---------------------------------------------------------------------------
+DEFAULT_EVAL_NUM = 64
+# Fixed seed for the held-out random sample, so every eval pass scores the SAME subset and the
+# eval curve is comparable across steps.
+EVAL_SAMPLE_SEED = 12345
+# Default pool size to MATERIALIZE and sample from when `eval_examples` is small (data load is
+# cheap; only generation is the real cost), so a multi-million-row Hub split isn't fully built just
+# to pick a few-dozen-row sample. The pool must hold at least `n` rows to draw an n-row sample, so
+# the caller materializes max(n, EVAL_POOL_CAP): this cap is the FLOOR for the common small-n case,
+# not a ceiling — a run that explicitly sets eval_examples ABOVE the cap is asking to score that
+# many rows and gets exactly that (the bound is only a default for the few-dozen-row default n).
+EVAL_POOL_CAP = 2048
+
+
+def sample_eval_rows(pool: list, n: int, seed: int = EVAL_SAMPLE_SEED) -> list:
+    """A FIXED seeded random sample of ``n`` rows from ``pool`` (kept in original order).
+
+    The whole pool is returned when ``n <= 0`` or ``n >= len(pool)`` (asking for at least as many
+    as exist means "eval them all"). Same ``seed`` -> same subset on every pass, so the held-out
+    eval curve is comparable across optimizer steps rather than jumping around on a fresh sample.
+    """
+    if n <= 0 or n >= len(pool):
+        return pool
+    idx = sorted(random.Random(seed).sample(range(len(pool)), n))
+    return [pool[i] for i in idx]
+
+
+def eval_config(
+    default_max_new: int, *, spec_every: int | None = None, spec_eval_examples: int | None = None
+) -> dict:
+    """Resolve the mid-run-eval knobs, both from the run's ``[train]`` TOML:
+      * CADENCE — ``eval_every_steps`` (``spec_every``); 0/unset disables.
+      * SAMPLE SIZE — ``eval_examples`` (``spec_eval_examples``): how many held-out rows each pass
+        scores. The eval takes a FIXED seeded random sample of this many rows instead of the whole
+        split, so a huge eval set can't dominate training and the curve stays comparable across
+        passes. None/0 -> the built-in default (``DEFAULT_EVAL_NUM``).
+
+    Everything else comes from the ENVIRONMENT: the eval queries are the env's held-out
+    ``eval_dataset``, the grading is its rubric (reward + eval-metric metrics), the completion
+    budget equals the run's normal ``max_tokens`` (``default_max_new``), and the pass threshold
+    is the env's own.
+    """
+    every = max(0, int(spec_every)) if spec_every is not None else 0
+    spec_num = spec_eval_examples if (spec_eval_examples and spec_eval_examples > 0) else None
+    num_examples = spec_num if spec_num is not None else DEFAULT_EVAL_NUM
+    return {
+        "every_steps": every,
+        "num_examples": max(1, num_examples),  # the held-out random-sample size (>=1)
+        "max_new_tokens": max(1, int(default_max_new)),  # = the run's normal completion budget
+    }
+
+
+def build_hf_greedy_generate(
+    model, tok, *, stop: list[str] | None
+) -> Callable[[list[int], int], tuple[list[int], list[float], str]]:
+    """A greedy (deterministic) generate over the TRAINER'S model via ``transformers.generate``,
+    returning ``(token_ids, logprobs, text)`` like the multi-turn rollout's generate.
+
+    Uses the model directly (NOT the colocate vLLM engine, whose out-of-band use from a callback
+    hangs GRPO). Runs in eval + ``no_grad`` and restores train mode; ``use_cache=True`` is forced
+    so generation works even when training has it off under gradient checkpointing (no backward
+    happens here, so checkpointing is irrelevant). One prompt at a time keeps the KV footprint to
+    a single sequence; an OOM raises (caught upstream -> ``eval_skipped``), never hangs.
+
+    Stop sequences are honored via ``stop_strings`` so generation actually STOPS at the stop
+    (rather than post-hoc truncating the text only) — this keeps the returned ``token_ids`` and
+    ``text`` in lockstep (``text == decode(token_ids)``), which the multi-turn ``rollout_one``
+    prefix invariant requires; truncating text alone would desync them."""
+    import torch
+
+    pad_id = tok.pad_token_id if tok.pad_token_id is not None else tok.eos_token_id
+    stop_kwargs = {"stop_strings": list(stop), "tokenizer": tok} if stop else {}
+
+    def generate(prefix_ids: list[int], max_tokens: int):
+        input_ids = torch.tensor([list(prefix_ids)], dtype=torch.long, device=model.device)
+        was_training = model.training
+        try:
+            model.eval()
+            with torch.no_grad():
+                out = model.generate(
+                    input_ids,
+                    attention_mask=torch.ones_like(input_ids),
+                    max_new_tokens=max(1, int(max_tokens)),
+                    do_sample=False,  # greedy / deterministic eval
+                    use_cache=True,
+                    pad_token_id=pad_id,
+                    **stop_kwargs,
+                )
+        finally:
+            if was_training:
+                model.train()
+        # text == decode(new_ids): never post-hoc truncate one without the other (see docstring).
+        new_ids = [int(t) for t in out[0][input_ids.shape[1] :].tolist()]
+        text = tok.decode(new_ids, skip_special_tokens=True)
+        return new_ids, [0.0] * len(new_ids), text
+
+    return generate

code/flash/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/flash/engine/recipe.py

@@ -0,0 +1,86 @@
+"""Frozen, shared Flash 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
+
+from dataclasses import dataclass, field
+
+# ----------------------------------------------------------------------------
+# Model identity
+# ----------------------------------------------------------------------------
+# Recipe fallback base model. The worker resolves JOB_SPEC.model (carried by the full
+# JobSpec) first and only falls back to RECIPE.hf_model_id; this literal is the
+# last-resort default when the spec carries no model.
+# 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 = "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 ("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/flash/engine/vram.py

@@ -0,0 +1,367 @@
+"""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 flash.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
+# SFT activations peak on the worker's PER-DEVICE micro-batch, not [train].batch_size
+# (which is the global/effective batch realized via gradient accumulation). The worker
+# caps the micro-batch at 4: per_device = min(batch_size, 4). Mirror that here so an
+# unset/long-context SFT run (batch defaults low) still reserves the micro-batch activation
+# peak, and a large effective batch isn't mis-counted as resident VRAM (it's grad-accum,
+# not in-flight activations).
+_SFT_PER_DEVICE_BS_DEFAULT = 4
+
+
+def _sft_per_device_bs() -> int:
+    """The worker's per-device SFT micro-batch — the activation-peak driver to size against.
+
+    SFT micro-batch is a MANAGED default: the control plane no longer forwards
+    ``SFT_PER_DEVICE_BS`` to the worker (build_worker_env dropped the tuning allowlist), and the
+    worker's own process env never carries it, so the worker always runs the fixed default. The
+    allocator must size against that SAME fixed value — reading the control-plane process env here
+    would size a card for a micro-batch the worker never uses, under-routing an
+    ``SFT_PER_DEVICE_BS=1`` operator env to a too-small GPU that then OOMs at the default
+    micro-batch 4 (the asymmetry the env-knobs cleanup removed everywhere else)."""
+    return _SFT_PER_DEVICE_BS_DEFAULT
+# 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 logits budget (6 GB): 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 the
+        # logits budget (6 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)
+    # SFT: the activation peak is the worker's per-device micro-batch (capped at 4),
+    # NOT the global/effective batch_size (gradient accumulation realizes
+    # that). Size to the micro-batch the worker actually runs: a default/long-context run reserves
+    # for the per-device cap (no under-routing to a too-small card), while a large effective
+    # batch_size is capped at it (no over-routing, since accum isn't resident VRAM).
+    sft_per_device = min(max(1, batch_size), _sft_per_device_bs())
+    return base + _ACT_COEF * sft_per_device * (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
+
+    max_tokens = _pos_int(_g(train, "max_tokens"), None)
+    # Default sequence length when [train].max_length is unset. For GRPO this must MIRROR what
+    # run_rl() actually starts vLLM at — max(1024, RLConfig.max_prompt_len + completion) — not a
+    # flat 1024, or the allocator can pick a GPU sized for 1024 tokens while the worker launches a
+    # ~2368-token (3584 with thinking) engine and OOMs after provisioning. Completion = the run's
+    # [train].max_tokens override, else the recipe's thinking/non-thinking completion default.
+    if (algorithm or "").lower() in ("grpo", "rl"):
+        from flash.engine.recipe import RECIPE
+
+        _rl = RECIPE.rl
+        _completion = max_tokens or (
+            _rl.max_completion_len_thinking if thinking else _rl.max_completion_len
+        )
+        _grpo_default_len = max(1024, _rl.max_prompt_len + int(_completion))
+    else:
+        _grpo_default_len = 1024
+    seq_len = _pos_int(_g(train, "max_length"), _grpo_default_len)
+    lora_rank = _pos_int(_g(train, "lora_rank"), 32)
+    group_size = _pos_int(_g(train, "group_size"), 8)
+    # Default to the worker's per-device SFT micro-batch (4): an unset
+    # [train].batch_size still realizes that micro-batch on the worker, so size for it
+    # rather than 1 (which would under-route a long-context SFT run to a too-small card).
+    batch_size = _pos_int(_g(train, "batch_size"), _sft_per_device_bs())
+
+    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 flash.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("FLASH_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/flash/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/flash/envs/adapter.py

@@ -0,0 +1,717 @@
+"""Adapter that runs Prime Intellect ``verifiers`` / Environments Hub envs on Flash.
+
+Wraps a ``verifiers`` ``Environment`` (``SingleTurnEnv``, ``MultiTurnEnv``, ``ToolEnv`` and
+its subclasses) in Flash's small ``Environment`` protocol so Hub environments run unchanged
+on Flash'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 — ``flash.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;
+    eval-metric 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
+
+
+# Flash-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 Flash-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 Flash-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, n: int = -1):
+    """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`` (default -1 = all rows — the adapter does its
+    own fixed subset selection; callers pass a positive cap to avoid materializing a huge split)
+    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"] = n
+    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. Eval-metric (optional/monitor) funcs are run through ``_run_eval_metric``,
+    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_eval_metric(func, available: dict) -> None:
+    """Run a eval-metric 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):
+    """Flash 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 (eval-metric 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 Flash 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 Flash; use a per-completion reward."
+                )
+        self._parser = getattr(vf_env, "parser", None)
+
+    # -- data -------------------------------------------------------------
+    def dataset(self, split: str, limit: int | None = None) -> list[dict]:
+        is_eval = split in {"eval", "validation", "test"}
+        if is_eval:
+            src = self._eval_env or self._env
+            # ``limit`` caps materialization at the source (mid-run eval only needs a small slice);
+            # a getter that ignores ``n`` still returns everything, so _fixed_subset / the caller's
+            # slice remain the backstop. -1 = all rows (the no-cap default).
+            n = limit if (limit is not None and limit > 0) else -1
+            # 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, n=n)
+            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, n=n)
+                if eval_ds is None:
+                    eval_ds = getattr(src, "dataset", None)
+            rows = _rows_to_list(eval_ds)
+            # An explicit positive ``limit`` means the caller (mid-run eval) wants a RAW pool of up
+            # to ``limit`` rows and does its OWN seeded sampling on top — so don't also apply the
+            # ``[environment.params] eval_examples`` subset here, which would silently shrink the
+            # pool below ``limit`` and starve the caller's sample (it already capped the pool size
+            # via ``limit``). ``_fixed_subset`` still governs the plain ``dataset("eval")`` path
+            # (the "eval on a different env" feature, where the param IS the intended sample size).
+            if limit is not None and limit > 0:
+                return rows
+            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 has_eval_split(self) -> bool:
+        """True when a DISTINCT held-out eval split exists (a separate eval env, or the env's
+        ``get_eval_dataset``/``eval_dataset``). False means :meth:`dataset` would fall back to
+        train rows — so a caller (mid-run eval) can warn instead of reporting train data as
+        held-out. Best-effort: a getter that raises is treated as no eval split."""
+        if self._eval_env is not None:
+            return True
+        try:
+            if (
+                _call_dataset_getter(self._env, "get_eval_dataset", seed=self._eval_seed)
+                is not None
+            ):
+                return True
+        except Exception:
+            return False
+        return getattr(self._env, "eval_dataset", None) is not None
+
+    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 eval-metric ones — they may
+        mutate the shared ``state`` (so a subsequent weighted func sees their work) or exist
+        only to be logged. Eval-metric 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 eval-metric 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:
+                # Eval-metric 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_eval_metric(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 evaluate(self, completion: str, example: dict, state: dict | None = None) -> dict:
+        """One pass over the rubric returning the training ``reward`` AND the env's separate
+        ``metrics`` — each EVAL-METRIC rubric func's raw (unweighted) score, by name.
+
+        Eval-metric funcs are how a verifiers ``environment.py`` expresses an EVALUATION signal
+        distinct from the GRPO reward: an ``exact_match`` / ``accuracy`` monitor added with
+        ``rubric.add_metric(fn, weight=0.0)`` does not shape training (weight 0) but measures
+        quality. :meth:`scores_breakdown`/:meth:`reward` deliberately omit these; mid-run eval
+        wants them, so this method surfaces them WITHOUT a second rubric pass (a ``JudgeRubric``
+        is sampled at most once). Weighted funcs still propagate exceptions (a broken weighted
+        reward fails the run); eval-metric monitors stay guarded (a thrown monitor is skipped,
+        never fails eval). Order is preserved so a monitor can prep shared ``state`` for a later
+        weighted func, exactly as in :meth:`scores_breakdown`.
+
+        Returns ``{"reward": <weighted total>, "metrics": {name: raw_score, ...}}``; an env with
+        no rubric falls back to the substring ``answer_match`` as both reward and (empty) metrics.
+        """
+        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 {"reward": score, "metrics": {}}
+        available = self._reward_available(completion, example, state)
+        total = 0.0
+        metrics: dict[str, float] = {}
+        for func, weight in self._reward_pairs:
+            name = getattr(func, "__name__", str(func))
+            if not weight:
+                # Eval-metric = an eval/monitor metric: run it (guarded — a thrown monitor must
+                # not fail eval) and record its RAW score; it never touches the reward total.
+                try:
+                    raw = _invoke_reward(func, available)
+                except Exception:
+                    continue
+                key = name
+                i = 1
+                while key in metrics:  # keep colliding metric names distinct
+                    key = f"{name}_{i}"
+                    i += 1
+                metrics[key] = raw
+                continue
+            total += float(weight) * _invoke_reward(func, available)
+        return {"reward": total, "metrics": metrics}
+
+    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 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 Flash.
+
+    ``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()
+    vf_env = vf.load_environment(vf_load_id(env_id), **_drop_reserved_kwargs(kwargs))
+    eval_ref = eval_env_id
+    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/flash/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/flash/envs/registry.py

@@ -0,0 +1,79 @@
+"""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
+
+from pathlib import Path
+
+from .._fileio import read_json_or_empty, secure_json_write
+from .base import Environment
+
+# Manifest of installed verifiers / Prime Hub environments (written by `slm env install`).
+INSTALLED_MANIFEST = Path.home() / ".flash" / "envs.json"
+
+
+def load_installed_manifest() -> dict:
+    return read_json_or_empty(INSTALLED_MANIFEST)
+
+
+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 {})}
+    # The manifest can hold a credentialed --extra-index-url, so write it with private perms.
+    secure_json_write(INSTALLED_MANIFEST, manifest)
+
+
+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 Flash'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/flash/mcp/__init__.py

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

code/flash/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 Flash 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 flash.catalog import public_model_rows
+from flash.client import client_from_config
+from flash.client.specs import spec_payload
+from flash.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/flash/providers/__init__.py

@@ -0,0 +1,60 @@
+"""Pluggable GPU substrates (RunPod Flash + Vast.ai verified datacenters).
+
+The training worker (``flash.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 flash.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 flash.providers.runpod import PROVIDER
+
+        return PROVIDER
+    if key == "vast":
+        from flash.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 FLASH_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/flash/providers/_auth.py

@@ -0,0 +1,24 @@
+"""Shared operator-credential helpers for the GPU providers.
+
+Every provider authenticates the same way: a single API key read ONLY from an
+environment variable on the control-plane host (never config files, never shipped to
+workers). The per-provider ``auth.py`` modules wrap these with their own env-var name
+and error message.
+"""
+
+from __future__ import annotations
+
+import os
+
+
+def load_provider_key(env_var: str) -> str | None:
+    """Provider API key from ``env_var`` (operator configuration), or None."""
+    return os.environ.get(env_var) or None
+
+
+def ensure_provider_auth(env_var: str, missing_message: str) -> str:
+    """Return the provider key from ``env_var``; raise ``missing_message`` if unset."""
+    key = load_provider_key(env_var)
+    if not key:
+        raise RuntimeError(missing_message)
+    return key

code/flash/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/flash/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/flash/providers/allocator.py

@@ -0,0 +1,262 @@
+"""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 (FLASH_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 flash._logging import get_logger
+from flash.providers import PROVIDER_NAMES, available_providers, get_provider
+from flash.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,
+) -> 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 flash.engine.vram import model_required_vram_gb
+
+    return model_required_vram_gb(
+        model_id,
+        algorithm,
+        train=train,
+        thinking=thinking,
+        headroom=vram_headroom(),
+    )
+
+
+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,
+) -> 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 flash.providers.base import GPU_INFO
+    from flash.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
+        )
+    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(),
+    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.
+    """
+    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)
+    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")
+            )
+            cands += vcands
+        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/flash/providers/base.py

@@ -0,0 +1,540 @@
+"""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
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from flash.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 Flash'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 Flash 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 Flash 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}; Flash 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 — the per-run ``[gpu]
+    allow_unvalidated`` flag only (managed; no global env override)."""
+    return bool(explicit)
+
+
+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
+    ``flash.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 flash.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 (``flash.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 flash.engine.vram import model_required_vram_gb
+    from flash.providers.allocator import vram_headroom
+
+    # Honor FLASH_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/flash/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 ``flash.providers.<name>.preflight``.
+"""
+
+from __future__ import annotations
+
+import os
+
+from flash.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 flash.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 Flash control plane is missing required operator configuration:\n"
+            + "\n".join(problems)
+            + "\n\nSet these on the control-plane host."
+        )

code/flash/providers/runpod/__init__.py

@@ -0,0 +1,108 @@
+"""RunPod Flash provider: managed, serverless GPUs (no Docker) for Flash.
+
+Fine-tuning runs on a dedicated RunPod GPU provisioned by Flash. A decorated Python
+handler (``train._train_body``) executes ``flash.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 flash.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 flash.providers.runpod.preflight import missing_credentials
+
+        return missing_credentials(require_hf=require_hf)
+
+    def gpu_classes(self) -> list[GpuClass]:
+        from flash.providers.runpod.gpus import gpu_classes
+
+        return gpu_classes()
+
+    def hourly_rate(self, gpu: str) -> float:
+        from flash.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 flash.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 flash.providers.runpod.jobs import JobHandle as RunpodJobHandle
+        from flash.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 flash.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 flash.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 flash.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/flash/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 flash.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: ~/.flash/config.json holds the *Flash* 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/flash/providers/runpod/auth.py

@@ -0,0 +1,24 @@
+"""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 Flash
+key. Deliberately env-only: ``~/.flash/config.json`` holds the *Flash* key, which
+must never be mistaken for a RunPod key.
+"""
+
+from __future__ import annotations
+
+from .._auth import ensure_provider_auth, load_provider_key
+
+_ENV_VAR = "RUNPOD_API_KEY"
+
+
+def load_api_key() -> str | None:
+    """API key from the environment (operator configuration)."""
+    return load_provider_key(_ENV_VAR)
+
+
+def ensure_auth() -> str:
+    """Ensure ``RUNPOD_API_KEY`` is set; raise if unavailable."""
+    return ensure_provider_auth(_ENV_VAR, "no RunPod API key found; set RUNPOD_API_KEY on the control-plane host")

code/flash/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 flash.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 flash.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/flash/providers/runpod/jobs.py

@@ -0,0 +1,519 @@
+"""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 flash._logging import get_logger
+from flash.providers._poll import PollErrorTracker, make_say, surface_heartbeat
+from flash.providers.base import PollResult, canonical_gpu
+from flash.providers.runpod import api as runpod_api
+from flash.providers.runpod.gpus import flash_gpu
+from flash.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).
+# 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"}
+)
+
+
+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.
+    """
+    return {"stall_after_s": 1500.0, "setup_grace_s": 3000.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 flash.providers.runpod.auth import ensure_auth
+
+    ensure_auth()
+    _patch_runpod_backoff()
+    friendly = canonical_gpu(friendly_gpu)
+    name = endpoint_name(friendly, name_suffix)
+    # The baked WORKER_IMAGE is now a self-contained RunPod Serverless worker (its CMD runs
+    # rp_handler.py, which reads job["input"] and runs the training) — deploy it directly (Flash
+    # "client mode"). build_function_input then sends the payload as the job input. FLASH_WORKER_IMAGE
+    # overrides the baked image (e.g. a hotfix tag); since WORKER_IMAGE is a non-empty constant the
+    # image is always set, so the boot-install/live-function path is only reachable if both are
+    # explicitly cleared (not a normal configuration).
+    image = os.environ.get("FLASH_WORKER_IMAGE") or 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),
+            gpu_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.
+    """
+    if os.environ.get("FLASH_WORKER_IMAGE") or WORKER_IMAGE:
+        # Baked serverless-worker image (client mode): the image's rp_handler reads job["input"]
+        # and calls _train_body, so the job input IS the train payload (submit_job wraps it in
+        # {"input": ...}). No live-function source, no boot-install deps.
+        return payload
+    # Boot-install fallback (Flash default image + live function): ship _train_body's source for the
+    # generic worker to run, plus the GPU-scoped deps to install on first use (drops fla on Hopper).
+    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)
+    return {
+        "function_name": "_train_body",
+        "function_code": source,
+        "args": serialize_args((payload,)),
+        "accelerate_downloads": True,
+        "dependencies": resolve_worker_deps(canonical_gpu(friendly_gpu) if friendly_gpu else None),
+        "system_dependencies": WORKER_SYSTEM_DEPS,
+    }
+
+
+def decode_output(output) -> dict:
+    """Decode a queue-job output into the worker's metrics dict. Handles BOTH job shapes:
+
+    - Flash LIVE-function (boot-install path): a FunctionResponse envelope
+      ``{"success": True, "result": <base64 cloudpickle of the dict>}``.
+    - Client-mode SERVERLESS handler (baked-image path): our baked rp_handler returns
+      ``_train_body(...)``'s metrics dict, which RunPod surfaces as ``job["output"]`` directly —
+      no envelope. The metrics dict has no ``success``/``result`` keys, so we return it as-is.
+    """
+    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)}")
+    # Flash live-function envelope (has success/result/error keys).
+    if "success" in output or "result" in 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}"
+        )
+    # Client-mode serverless handler: the metrics dict IS the output (baked rp_handler).
+    if output.get("error"):
+        # Mirror the Flash path: append the worker stdout tail when present so poll_job's
+        # root-cause diagnostics (e.g. a vLLM crash) survive the client-mode failure shape too.
+        stdout_tail = (output.get("stdout") or "")[-1500:]
+        msg = f"Remote execution failed: {output['error']}"
+        if stdout_tail:
+            msg += f"\n--- worker stdout tail ---\n{stdout_tail}"
+        raise RuntimeError(msg)
+    return output
+
+
+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,
+    unhealthy_grace_s: float = 240.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
+    unhealthy_since: float | None = None  # first time the worker was seen stuck UNHEALTHY
+    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 {}
+                usable = workers.get("running") or workers.get("ready") or workers.get("idle")
+                recovering = workers.get("initializing")
+                if any(workers.get(k) for k in ("throttled", "unhealthy", "initializing")) or not usable:
+                    say(f"queued; workers: {workers}")
+                # Fail fast on a worker stuck UNHEALTHY: a dead worker / failed image pull won't
+                # self-recover, so don't burn the full setup_grace_s (~50 min) waiting on it — once
+                # it has stayed unhealthy with nothing usable or (re)initializing for
+                # unhealthy_grace_s, return a (retryable) stall so the runner re-provisions a FRESH
+                # endpoint (fresh image pull, likely a different host). Observed: a mutable image
+                # tag republished mid-pull corrupts the worker -> unhealthy, and a fresh pull fixes it.
+                if workers.get("unhealthy") and not usable and not recovering:
+                    if unhealthy_since is None:
+                        unhealthy_since = time.time()
+                    elif time.time() - unhealthy_since > unhealthy_grace_s:
+                        return PollResult(
+                            False,
+                            failure="stalled",
+                            detail=f"worker stuck unhealthy for "
+                            f"{int(time.time() - unhealthy_since)}s while IN_QUEUE (likely a failed "
+                            f"image pull); retrying on a fresh endpoint",
+                        )
+                else:
+                    unhealthy_since = None  # recovered / usable worker appeared
+            except Exception:
+                # Health surfacing is diagnostic only; a probe failure must not stop polling.
+                pass
+        # 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 flash.envs.registry import worker_hub_env_ids, worker_pip_for_env
+    from flash.providers.runpod.train import _run_suffix, build_worker_env, chalk_extra_pip
+
+    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 runs for EVERY job here (the durable baked-image path skips resolve_worker_deps /
+    # FLASH_WORKER_EXTRA_DEPS in build_function_input, but _train_body always pip-installs
+    # extra_pip), so the opt-in chalk spec is appended here to reach default runs.
+    extra_pip = (
+        list(spec.environment.pip) or worker_pip_for_env(spec.environment.id)
+    ) + chalk_extra_pip(spec)
+    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),
+    }
+    try:
+        job_id = runpod_api.submit_job(endpoint_id, build_function_input(payload, spec.gpu.type))
+    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/flash/providers/runpod/preflight.py

@@ -0,0 +1,30 @@
+"""Fail-fast credential checks for the RunPod substrate (operator-side).
+
+These run when the Flash 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 Flash key?", see flash/client).
+"""
+
+from __future__ import annotations
+
+import os
+
+from flash.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/flash/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 flash._logging import get_logger
+
+logger = get_logger(__name__)
+
+CACHE_TTL_S = 6 * 3600.0  # 6h price cache
+_CACHE_PATH = Path.home() / ".flash" / "gpu_rates.json"
+_MEM: dict = {"ts": 0.0, "rates": {}}
+
+
+def _static_rates() -> dict[str, float]:
+    from flash.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 flash.providers.base import GPU_INFO
+    from flash.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: FLASH_SKIP_NET (or any fetch failure) returns the static rates.
+    """
+    static = _static_rates()
+    if os.environ.get("FLASH_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 flash.providers.base import canonical_gpu
+
+    name = canonical_gpu(gpu_name)
+    return live_rates().get(name) or _static_rates()[name]

code/flash/providers/runpod/train.py

@@ -0,0 +1,952 @@
+"""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 ``flash`` package from the HF dataset repo (uploaded by
+``upload_code`` before submit), adds it to ``PYTHONPATH``, and runs
+``flash.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 flash._logging import get_logger
+from flash.providers.base import canonical_gpu, gpu_short
+from flash.providers.runpod.gpus import flash_gpu
+from flash.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.
+    # NB: freesolo-chalk (custom Triton/CUDA kernels, install-on-call — calling an installer IS
+    # the opt-in; chalk reads NO env vars) is NOT baked in by default — it isn't on PyPI yet, and a
+    # bad/inaccessible spec here would abort worker boot. flash auto-detects chalk if present
+    # (flash/engine/chalk_kernels.py). To enable kernels on a DEFAULT remote run: set the per-kernel
+    # FLASH_* selection flags (FLASH_MLP_KERNEL, FLASH_FP8_BASE, FLASH_TRITON_LORA, ...) AND set
+    # FLASH_CHALK_SPEC to an installable chalk spec (a git URL with access, or a wheel). The submit
+    # path (chalk_extra_pip) then appends that spec to the worker's `extra_pip`, which the worker
+    # pip-installs for EVERY job (baked-image RunPod _train_body + Vast bootstrap). Do NOT rely on
+    # FLASH_WORKER_EXTRA_DEPS / FLASH_WORKER_DEPS for this: the durable baked-image submit path
+    # (jobs.build_function_input) returns the raw payload and never consults resolve_worker_deps, so
+    # those vars don't reach a default run; and FLASH_WORKER_DEPS would also REPLACE the whole stack.
+]
+# 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 FLASH_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. Always used on both Vast and RunPod — there is no operator override and no generic
+# fallback image. Must be published to GHCR + made public before runs can pull it.
+WORKER_IMAGE = "ghcr.io/freesolo-co/flash-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: FLASH_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("FLASH_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 flash.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 FLASH_WORKER_DEPS requires.
+    extra = os.environ.get("FLASH_WORKER_EXTRA_DEPS")
+    if extra:
+        import shlex
+
+        deps = deps + [d for d in shlex.split(extra) if d.strip()]
+    return deps
+
+
+# FLASH_* flags that select a chalk install-on-call kernel (see engine.chalk_kernels). Any one
+# of these being set means the run opted into chalk, so chalk must be installed on the worker.
+_CHALK_KERNEL_FLAGS = (
+    "FLASH_MLP_KERNEL",
+    "FLASH_MLP_FP8",
+    "FLASH_FP8_BASE",
+    "FLASH_TRITON_LORA",
+    "FLASH_EMBED_KERNEL",
+    "FLASH_QKV_KERNEL",
+    "FLASH_ROPE_KERNEL",
+)
+
+
+def _effective_worker_env(spec=None) -> dict[str, str]:
+    """The env the WORKER process will actually see, for chalk-selection decisions.
+
+    chalk install-on-call is selected by ``FLASH_*`` flags read on the worker from its own process
+    env, which ``build_worker_env`` builds as the control-plane ``os.environ`` allowlist with the
+    run's ``[worker_env]`` overrides merged ON TOP (per-run ``spec.worker_env`` wins). A run that
+    opts into chalk via its ``[worker_env]`` block therefore sets the flag the worker reads — so the
+    SAME merge must decide whether chalk is selected and whether its spec is added to ``extra_pip``;
+    reading bare ``os.environ`` here would miss a per-run ``[worker_env]`` opt-in and the kernels
+    would never install for that run.
+
+    Returns ``os.environ`` overlaid with ``spec.worker_env`` (string-coerced). ``spec=None`` (no
+    per-run env) collapses to plain ``os.environ``.
+    """
+    eff: dict[str, str] = dict(os.environ)
+    for k, v in (getattr(spec, "worker_env", None) or {}).items():
+        eff[str(k)] = str(v)
+    return eff
+
+
+def _chalk_selected(spec=None) -> bool:
+    """True if any FLASH_* chalk kernel-selection flag is truthy in the EFFECTIVE worker env.
+
+    Reads the per-run ``[worker_env]`` (``spec.worker_env``) merged over ``os.environ`` so a chalk
+    opt-in set only in the run's ``[worker_env]`` block is detected (see ``_effective_worker_env``).
+    """
+    env = _effective_worker_env(spec)
+    for name in _CHALK_KERNEL_FLAGS:
+        v = env.get(name)
+        if v is not None and v.strip().lower() not in ("", "0", "false", "no", "off"):
+            return True
+    return False
+
+
+def chalk_extra_pip(spec=None) -> list[str]:
+    """Chalk pip spec(s) to ADD to the worker's ``extra_pip`` when a chalk kernel is selected.
+
+    This is the install hook that runs for DEFAULT remote jobs: the baked-image RunPod path
+    (``_train_body`` -> ``pip install *extra_pip``) and the Vast bootstrap both consume the
+    payload's ``extra_pip`` regardless of ``WORKER_IMAGE`` — unlike ``FLASH_WORKER_EXTRA_DEPS``
+    / ``resolve_worker_deps``, which the durable ``build_function_input`` baked-image path skips.
+
+    Selection (and the ``FLASH_CHALK_SPEC`` lookup) is resolved against the EFFECTIVE worker env —
+    the run's ``[worker_env]`` merged over ``os.environ`` — so it matches exactly what the worker
+    process will see (``build_worker_env``) and a per-run ``[worker_env]`` opt-in installs chalk.
+
+    freesolo-chalk is unpublished, so there is no auto-installable default: the operator MUST set
+    ``FLASH_CHALK_SPEC`` to an installable spec (a git URL with access, or a wheel/path). When a
+    chalk kernel flag is set but ``FLASH_CHALK_SPEC`` is empty we log a warning and add nothing —
+    ``install_chalk_kernels`` then finds no chalk on the worker and safely no-ops.
+    """
+    if not _chalk_selected(spec):
+        return []
+    spec_str = _effective_worker_env(spec).get("FLASH_CHALK_SPEC", "").strip()
+    if not spec_str:
+        logger.warning(
+            "a FLASH_* chalk kernel is selected but FLASH_CHALK_SPEC is unset; freesolo-chalk is "
+            "unpublished so it can't be auto-installed — set FLASH_CHALK_SPEC to an installable "
+            "spec (git URL or wheel) or the chalk kernels will no-op on the worker."
+        )
+        return []
+    import shlex
+
+    return [d for d in shlex.split(spec_str) if d.strip()]
+
+
+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 ``flash`` 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 ``flash`` 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 flash
+
+    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(flash.__file__))
+    api = HfApi(token=token)
+    # Run artifact repos are private by default. TEST-ONLY escape hatch (NOT for production):
+    # FLASH_HF_REPO_PRIVATE=0 makes them public so a free-tier/wrong-namespace HF account can run
+    # without the private-storage 403. Production keeps private=True.
+    _priv = os.environ.get("FLASH_HF_REPO_PRIVATE", "1").strip().lower() not in ("0", "false", "no")
+    api.create_repo(repo, repo_type="dataset", exist_ok=True, private=_priv)
+    api.update_repo_settings(repo_id=repo, repo_type="dataset", private=_priv)
+    api.upload_folder(
+        folder_path=pkg_dir,
+        path_in_repo="code/flash",
+        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)
+    # Always pass the spec via a file (FLASH_JOB_SPEC_PATH): a large inline spec can blow past the
+    # ~128 KiB per-env-string exec limit ("Argument list too long"), and a file is ONE code path for
+    # every size (cheap write). load_job_spec_from_env reads it.
+    spec_path = "/tmp/job_spec.json"
+    with open(spec_path, "w") as sf:
+        sf.write(input_data["job_spec_json"])
+    env["FLASH_JOB_SPEC_PATH"] = spec_path
+    env.pop("FLASH_JOB_SPEC_JSON", None)
+    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", "flash.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 Flash process gets its own registry
+    under ``~/.flash/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() / ".flash" / "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, "_flash_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._flash_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.
+    Fully managed per-GPU (no override).
+    """
+    from flash.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 (``flash-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"flash-{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 flash.providers.runpod.auth import ensure_auth
+    from flash.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),
+        gpu_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),
+    )
+    # RunPod Flash needs its serverless runtime baked into the worker image; the prebuilt
+    # WORKER_IMAGE is Vast's cold-start image (no Flash runtime) and leaves the worker unhealthy if
+    # forced. RunPod boot-installs WORKER_DEPS on Flash's default template instead (cached as a
+    # Flash artifact). Optional FLASH_WORKER_IMAGE override for a RunPod-serverless-compatible image.
+    image = os.environ.get("FLASH_WORKER_IMAGE")
+    if image:
+        kwargs["image"] = 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 flash.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"flash-{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 (``flash-<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 ``flash-<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 flash.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 ~/.flash, 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 flash.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, FLASH_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.
+    # Resolve the override from [worker_env] AND the control-plane process env (worker_env wins,
+    # mirroring RL_VLLM_SLEEP above): a per-run [worker_env] PYTORCH_ALLOC_CONF is merged into the
+    # worker env later (and would win), but if it isn't counted as an explicit override HERE,
+    # _alloc_override stays falsy, FLASH_ALLOC_AUTO=1 is sent, and finalize_alloc_conf_for_sleep
+    # overwrites the operator's per-run pin.
+    _we = spec.worker_env or {}
+    _alloc_override = (
+        _we.get("PYTORCH_ALLOC_CONF")
+        or _we.get("PYTORCH_CUDA_ALLOC_CONF")
+        or 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).
+        "FLASH_ARM": "runpod",
+        "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.
+        **(
+            {"FLASH_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. FLASH_JUDGE_MODEL is the judge model id the optimizer-authored env
+    # reads (agents/common/prompt.py) to pick the JudgeRubric client model; forward the operator's
+    # control-plane override so SFT-eval/GRPO-reward/rejection-sampling judges don't silently fall
+    # back to the env's generated default. Forward any that the operator has set; absent ones are
+    # simply not passed (the env then uses its own default model).
+    for key in (
+        "HF_TOKEN",
+        "PRIME_API_KEY",
+        "OPENROUTER_API_KEY",
+        "OPENAI_API_KEY",
+        "FLASH_JUDGE_MODEL",
+    ):
+        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",
+        "FLASH_QUANT",
+        # W&B account routing: the API key AND the optional WANDB_ENTITY that routes runs into a
+        # team/service-account workspace. These are operator ACCOUNT config (where the dashboards
+        # land), not training tuning — without the entity, `wandb_report_to()` still enables W&B
+        # under the key's default (personal) entity, so team runs vanish from the configured
+        # workspace and service-account setups that require an explicit entity can fail. (Run TUNING
+        # is still NOT an operator env knob: flash is fully managed — every training setting uses the
+        # optimal default and the only per-run config is the spec's structured [train] fields. The
+        # worker also pins WANDB_PROJECT itself.)
+        "WANDB_API_KEY",
+        "WANDB_ENTITY",
+        "LORA_TARGETS",
+        # Periodic mid-run GRPO eval (engine/midrun_eval.eval_config): the cadence normally comes
+        # from the run's [train] eval_every_steps; FLASH_EVAL_EVERY_STEPS is an operator override
+        # (>0 enables), and FLASH_EVAL_NUM is a safety cap on held-out rows per eval. Everything
+        # else (eval set, grading, completion budget, threshold) comes from the environment/run.
+        "FLASH_EVAL_EVERY_STEPS",
+        "FLASH_EVAL_NUM",
+        # rl_step heartbeat-upload throttle (engine.worker._hb_min_interval_s). Operators raise this
+        # to stay under HuggingFace's 128 commits/hour-per-repo limit when several concurrent GRPO
+        # runs share one HF_REPO; the worker no-op's a non-positive/unparseable value back to 60s.
+        "FLASH_HEARTBEAT_MIN_S",
+        # FLASH_* chalk kernel-selection flags: chalk is install-on-call (reads NO env vars), so
+        # the WORKER decides which installers to run from these flags. install_chalk_kernels runs
+        # INSIDE the worker subprocess and reads them from its own process env, so a control-plane
+        # FLASH_* selection must be forwarded here or every chalk kernel silently no-ops on every
+        # remote run. FLASH_CHALK_SPEC is the install spec install_chalk_kernels points operators
+        # at (and is also consumed at submit time to add chalk to the worker's extra_pip).
+        "FLASH_MLP_KERNEL",
+        "FLASH_MLP_FP8",
+        "FLASH_MLP_FP8_DOWN",
+        "FLASH_FP8_BASE",
+        "FLASH_FP8_BASE_ATTN",
+        "FLASH_FP8_BASE_MLP",
+        "FLASH_FP8_BASE_MIN_K",
+        "FLASH_TRITON_LORA",
+        "FLASH_EMBED_KERNEL",
+        "FLASH_QKV_KERNEL",
+        "FLASH_ROPE_KERNEL",
+        # The chalk install spec itself — install_chalk_kernels warns pointing at it when a
+        # FLASH_* flag is set but chalk is absent.
+        "FLASH_CHALK_SPEC",
+    ):
+        # 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. Run-IDENTITY keys are control-plane-owned and excluded: the poller,
+    # deploy, and artifact paths all key off spec.run_id / spec.train.hf_repo, so letting a
+    # [worker_env] override RUN_ID/HF_REPO would make the worker upload under a different repo/prefix
+    # and orphan the artifacts (the poller would never find DONE/metrics, deploy can't locate the
+    # adapter). FLASH_ARM identifies the substrate (Vast rewrites it in its own bootstrap).
+    _RESERVED_WORKER_ENV = {"RUN_ID", "HF_REPO", "FLASH_ARM"}
+    for k, v in (getattr(spec, "worker_env", None) or {}).items():
+        if str(k).upper() in _RESERVED_WORKER_ENV:
+            continue  # control plane owns run identity; a per-run override would orphan artifacts
+        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 flash.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 is installed by the worker for EVERY job (baked-image RunPod _train_body and
+        # Vast bootstrap both pip-install it), so it's where the chalk spec must go to reach a
+        # default run — see chalk_extra_pip().
+        "extra_pip": (list(spec.environment.pip) or worker_pip_for_env(spec.environment.id))
+        + chalk_extra_pip(spec),
+        "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/flash/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 flash.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 flash.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 FLASH_SKIP_NET (offline/CI) disables Vast
+        # entirely; offline allocation then degrades deterministically to RunPod's
+        # static catalog.
+        if os.environ.get("FLASH_SKIP_NET"):
+            return False
+        return load_api_key() is not None
+
+    def preflight(self, require_hf: bool = True) -> list[str]:
+        from flash.providers.vast.preflight import missing_credentials
+
+        return missing_credentials(require_hf=require_hf)
+
+    def gpu_classes(self) -> list[GpuClass]:
+        from flash.providers.vast.gpus import gpu_classes
+
+        return gpu_classes()
+
+    def hourly_rate(self, gpu: str) -> float:
+        from flash.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 flash.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 flash.providers.runpod.jobs import make_hf_heartbeat_reader
+        from flash.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 flash.providers.vast.jobs import cancel
+
+        cancel(handle.to_dict())
+
+    def destroy(self, handle: JobHandle) -> None:
+        from flash.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 flash.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 flash.providers.vast.jobs import sweep_orphans
+
+        return sweep_orphans(active_labels=active_labels)
+
+
+PROVIDER: Provider = VastProvider()

code/flash/providers/vast/_bootstrap.py

@@ -0,0 +1,282 @@
+"""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 flash package from the HF dataset repo, then run the
+substrate-neutral worker (``flash.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 flash here.
+It reads its payload from ``/root/flash/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/flash/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["FLASH_JOB_SPEC_PATH"] = "/tmp/job_spec.json"
+        env.pop("FLASH_JOB_SPEC_JSON", None)
+    else:
+        env["FLASH_JOB_SPEC_JSON"] = spec_json
+    env["PHASE"] = payload["phase"]
+    env["SEED"] = str(payload["seed"])
+    # Compute substrate for the RunMetrics record (engine.worker reads FLASH_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["FLASH_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", "flash.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-flash-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
+            ):
+                _wb = subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "wandb>=0.17"], check=False
+                )
+                if _wb.returncode == 0 and importlib.util.find_spec("wandb") is not None:
+                    print("[wandb] installed wandb on-demand for W&B logging")
+                else:
+                    print(
+                        f"[wandb] on-demand wandb install FAILED (rc={_wb.returncode}); "
+                        "W&B logging will be disabled"
+                    )
+        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/flash/providers/vast/api.py

@@ -0,0 +1,219 @@
+"""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`` DATACENTER offers are searched (the
+server-side ``datacenter`` hosting-type filter is applied, since run secrets ship to the
+box); 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 flash.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,
+    limit: int = 64,
+    extra_q: dict | None = None,
+) -> list[dict]:
+    """Rentable single-GPU offers from verified DATACENTER hosts, cheapest first.
+
+    ``datacenter`` here is Vast's hosting-type filter (professional datacenters vs
+    consumer/hobbyist machines); results additionally carry ``hosting_type`` which
+    callers re-check (``usable_offers``) — never trust one filter layer alone.
+    """
+    # Apply Vast's server-side datacenter-only filter (hosting_type==1). usable_offers now rejects
+    # community/marketplace hosts unconditionally (run secrets ship to the box), so a mixed search
+    # would risk filling the price-sorted limit=64 page with community offers and reporting "no
+    # usable offers" even when verified-datacenter capacity exists just past the page. Filtering
+    # server-side keeps the page full of datacenter offers; usable_offers still re-checks
+    # hosting_type + verification + the reliability floor (belt and suspenders).
+    q: dict[str, Any] = {
+        "verified": {"eq": True},
+        "datacenter": {"eq": True},
+        "rentable": {"eq": True},
+        "num_gpus": {"eq": 1},
+        "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/flash/providers/vast/auth.py

@@ -0,0 +1,24 @@
+"""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
+
+from .._auth import ensure_provider_auth, load_provider_key
+
+_ENV_VAR = "VAST_API_KEY"
+
+
+def load_api_key() -> str | None:
+    """API key from the environment (operator configuration)."""
+    return load_provider_key(_ENV_VAR)
+
+
+def ensure_auth() -> str:
+    """Ensure ``VAST_API_KEY`` is set; raise if unavailable."""
+    return ensure_provider_auth(_ENV_VAR, "no Vast API key found; set VAST_API_KEY on the control-plane host")

code/flash/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 flash.providers.base import GpuClass
+
+__all__ = ["gpu_classes"]
+
+
+def gpu_classes() -> list[GpuClass]:
+    """The GPU classes Vast can provision (those with a ``vast_name``)."""
+    from flash.providers.base import GPU_INFO
+
+    return [g for g in GPU_INFO.values() if g.vast_name]

code/flash/providers/vast/jobs.py

@@ -0,0 +1,729 @@
+"""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 datacenter offer, 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 flash._logging import get_logger
+from flash.providers._poll import PollErrorTracker, make_say, surface_heartbeat
+from flash.providers.base import GPU_INFO, PollResult, min_cuda_modern, vast_gpu_for_offer
+from flash.providers.runpod.jobs import make_hf_heartbeat_reader, make_hf_text_reader
+from flash.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
+
+
+def usable_offers(
+    min_vram_gb: int,
+    disk_gb: float,
+    exclude_machine_ids: set[int] | frozenset[int] = frozenset(),
+) -> list[VastOffer]:
+    """Verified datacenter offers able to run the job, cheapest first.
+
+    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,
+    )
+    # Host tier: ALWAYS datacenter-only (hosting_type==1). The onstart payload ships run secrets
+    # (HF_TOKEN, PRIME_API_KEY, OpenRouter/OpenAI/W&B creds) to the box, so verified-but-lower-trust
+    # community/marketplace hosts (hosting_type 0) are never used — even verified + reliability-
+    # floored, they're a lower trust tier we don't ship secrets to.
+    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 ONLY verified datacenter hosts (hosting_type==1); community/marketplace
+        # (hosting_type==0) and anything else is rejected (we ship run secrets to the box).
+        _bad_host = r.get("hosting_type") != 1
+        if (
+            _bad_host
+            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 ""),
+            )
+        )
+    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 flash.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 ``flash-`` 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 ``flash-…`` labels and a
+    live run's instance could be swept (or fail to be protected)."""
+    return f"flash-{run_id}" if not run_id.startswith("flash-") 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 ``flash-``; 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 flash.envs.registry import worker_hub_env_ids, worker_pip_for_env
+    from flash.providers.runpod.train import build_worker_env, chalk_extra_pip
+
+    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),
+        # The Vast bootstrap pip-installs extra_pip for every job (provider/vast/_bootstrap.py),
+        # so the opt-in chalk spec rides along here to reach default runs — see chalk_extra_pip().
+        "extra_pip": (list(spec.environment.pip) or worker_pip_for_env(spec.environment.id))
+        + chalk_extra_pip(spec),
+        "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 flash.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
+# Flash vast worker (generated by flash.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/flash
+cat > /root/flash/payload.b64 <<'FLASH_PAYLOAD_EOF'
+{payload_b64}FLASH_PAYLOAD_EOF
+base64 -d /root/flash/payload.b64 > /root/flash/payload.json
+cat > /root/flash/bootstrap.py <<'FLASH_BOOTSTRAP_EOF'
+{bootstrap_src}FLASH_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 "FLASH: base worker dependency install failed" >&2; sleep 600; exit 1; }}
+"$PYBIN" /root/flash/bootstrap.py
+FLASH_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.
+[ "$FLASH_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" - <<'FLASH_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)
+FLASH_DESTROY_EOF
+exit $FLASH_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 flash.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),
+                env={},
+                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,
+                    )
+                    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,
+            )
+            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"flash-{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 Flash-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-``flash-`` 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("flash-"):
+            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. ``flash-100``)
+        # shield another run's orphan (``flash-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/flash/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 flash.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/flash/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: FLASH_SKIP_NET (or any failure) falls back to the
+static Vast snapshot carried on ``GpuClass.hourly_usd``.
+"""
+
+from __future__ import annotations
+
+import os
+
+from flash._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 flash.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: FLASH_SKIP_NET (or any fetch failure) returns the static rates.
+    """
+    static = _static_rates()
+    if os.environ.get("FLASH_SKIP_NET") or not os.environ.get("VAST_API_KEY"):
+        return static
+    try:
+        from flash.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 flash.providers.base import canonical_gpu
+
+    name = canonical_gpu(gpu_name)
+    return live_rates().get(name) or _static_rates().get(name, 0.0)

code/flash/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 flash.providers.runpod.train import (
+    WORKER_DEPS,
+    WORKER_SYSTEM_DEPS,
+    build_worker_env,
+    resolve_worker_deps,
+)
+from flash.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/flash/runner.py

@@ -0,0 +1,994 @@
+"""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 ~/.flash state dir (same root as server/db.py's DB_PATH) so a single
+# directory holds all control-plane state — mount one volume at ~/.flash to persist it.
+# Tests redirect them via monkeypatch.setattr(runner, "RUNS_DIR"/"RESULTS_DIR").
+_STATE_DIR = os.path.join(os.path.expanduser("~"), ".flash")
+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 flash.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 = "flash") -> 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)
+    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 (flash-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 flash.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 flash.providers import get_provider
+            from flash.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 flash.providers import get_provider
+    from flash.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 flash.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 FLASH_SKIP_NET takes the blocking
+    in-process submit instead (the job poll path is network-only).
+    """
+    from flash.providers.base import PollResult
+    from flash.providers.runpod.train import submit_train
+
+    if os.environ.get("FLASH_SKIP_NET"):
+        return submit_train(spec, seed, log=log)
+
+    from flash.providers import get_provider
+    from flash.providers.allocator import allocate, allocation_summary
+    from flash.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 flash.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
+    for attempt in range(max_retries + 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 flash.providers import get_provider
+                    from flash.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 flash.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),
+                # 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 flash.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 attempt < max_retries:
+                    time.sleep(10 * (attempt + 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") 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
+        print(
+            f"seed={seed} attempt={attempt} failed ({res.failure}); "
+            f"{'retrying (resume from last checkpoint)' if infra_shaped and attempt < max_retries else 'not retrying'}"
+            f"\n--- failure detail ---\n{(res.detail or '')[:2000]}\n---",
+            file=log,
+            flush=True,
+        )
+        if not infra_shaped or attempt >= max_retries:
+            break
+        # Step to the next-cheapest class only when THIS attempt actually provisioned one
+        # and it failed infra-shaped. 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
+    # 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 flash.providers import get_provider
+            from flash.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 flash.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 flash.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)