studio: keep frontend polling noise out of the engine console

uvicorn's access log lands in the engine tail, and the UI polls several
endpoints every few seconds — the console was mostly its own GET 200 lines.
access_log=False at the server (applies on restart) + a client-side filter
for 2xx GET/HEAD access-log lines (immediate, and covers servers started
before the flag).

.agents/skills/add-model-01-prep/scripts/clone_reference_repo.py

@@ -10,7 +10,9 @@ from pathlib import Path
 
 
 def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Clone a reference repo for FastVideo parity tests.")
+    parser = argparse.ArgumentParser(
+        description="Clone a reference repo for FastVideo parity tests."
+    )
     parser.add_argument("repo_url", help="Official reference repository URL")
     parser.add_argument("target_dir", help="Directory to clone into")
     parser.add_argument("--branch", help="Branch or tag to clone")
@@ -60,7 +62,9 @@ def gitignore_entry_for(target: Path) -> str:
     try:
         relative = resolved.relative_to(root)
     except ValueError as exc:
-        raise ValueError("--update-gitignore requires target_dir to be under the current directory") from exc
+        raise ValueError(
+            "--update-gitignore requires target_dir to be under the current directory"
+        ) from exc
 
     text = relative.as_posix().rstrip("/")
     return "/" + text + "/"

.agents/skills/add-model-01-prep/scripts/download_hf_weights.py

@@ -8,12 +8,14 @@ import os
 import sys
 from pathlib import Path
 
+
 HF_TOKEN_ENV_KEYS = ("HF_TOKEN", "HUGGINGFACE_HUB_TOKEN", "HF_API_KEY")
 
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
-        description="Download a HF model snapshot or selected files into a local directory.")
+        description="Download a HF model snapshot or selected files into a local directory."
+    )
     parser.add_argument("repo_id", help="HF repo id, for example Org/Model")
     parser.add_argument("local_dir", help="Destination directory")
     parser.add_argument("--repo-type", default="model", help="HF repo type (default: model)")

.agents/skills/add-model-01-prep/scripts/inspect_hf_layout.py

@@ -10,6 +10,7 @@ import sys
 from pathlib import Path
 from typing import Any
 
+
 HF_TOKEN_ENV_KEYS = ("HF_TOKEN", "HUGGINGFACE_HUB_TOKEN", "HF_API_KEY")
 RAW_WEIGHT_SUFFIXES = (".safetensors", ".pt", ".pth", ".ckpt", ".bin")
 KNOWN_COMPONENTS = {
@@ -33,7 +34,8 @@ KNOWN_COMPONENTS = {
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
-        description="Classify a HF repo or local directory as Diffusers, raw, custom, or unknown.")
+        description="Classify a HF repo or local directory as Diffusers, raw, custom, or unknown."
+    )
     parser.add_argument("source", help="HF repo id or local weights directory")
     parser.add_argument("--repo-type", default="model", help="HF repo type (default: model)")
     parser.add_argument("--revision", help="HF revision to inspect")
@@ -92,12 +94,14 @@ def load_remote_files(
 ) -> list[str]:
     from huggingface_hub import list_repo_files
 
-    return sorted(list_repo_files(
-        repo_id,
-        repo_type=repo_type,
-        revision=revision,
-        token=token,
-    ))
+    return sorted(
+        list_repo_files(
+            repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            token=token,
+        )
+    )
 
 
 def load_remote_model_index(
@@ -211,24 +215,24 @@ def build_result(args: argparse.Namespace) -> dict[str, Any]:
         "components_seen": components,
         "file_count": len(files),
         "file_scan_truncated": truncated,
-        "files_sample": files[:args.sample_limit],
+        "files_sample": files[: args.sample_limit],
     }
 
 
 def print_human(result: dict[str, Any]) -> None:
     for key in (
-            "source",
-            "source_kind",
-            "repo_type",
-            "revision",
-            "token_env",
-            "source_layout",
-            "needs_conversion",
-            "model_index_class",
-            "model_index_diffusers_version",
-            "model_index_error",
-            "file_count",
-            "file_scan_truncated",
+        "source",
+        "source_kind",
+        "repo_type",
+        "revision",
+        "token_env",
+        "source_layout",
+        "needs_conversion",
+        "model_index_class",
+        "model_index_diffusers_version",
+        "model_index_error",
+        "file_count",
+        "file_scan_truncated",
     ):
         value = result.get(key)
         if value is not None:

.agents/skills/add-model-02-parity/templates/component_parity_test.py

@@ -18,6 +18,7 @@ import pytest
 import torch
 from torch.testing import assert_close
 
+
 os.environ.setdefault("MASTER_ADDR", "localhost")
 os.environ.setdefault("MASTER_PORT", "29519")
 os.environ.setdefault("DISABLE_SP", "1")
@@ -34,10 +35,15 @@ FASTVIDEO_CONFIG_CLASS = "<FastVideoConfig>"  # TODO.
 FASTVIDEO_MODEL_MODULE = "fastvideo.models.<bucket>.<module>"  # TODO.
 FASTVIDEO_MODEL_CLASS = "<FastVideoModel>"  # TODO.
 
-OFFICIAL_REF_DIR = Path(os.getenv("<FAMILY_UPPER>_OFFICIAL_REF_DIR", REPO_ROOT / "<ReferenceDir>"))
-LOCAL_WEIGHTS_DIR = Path(os.getenv("<FAMILY_UPPER>_LOCAL_WEIGHTS_DIR", REPO_ROOT / "official_weights" / FAMILY))
-CONVERTED_WEIGHTS_DIR = Path(os.getenv("<FAMILY_UPPER>_CONVERTED_WEIGHTS_DIR",
-                                       REPO_ROOT / "converted_weights" / FAMILY))
+OFFICIAL_REF_DIR = Path(
+    os.getenv("<FAMILY_UPPER>_OFFICIAL_REF_DIR", REPO_ROOT / "<ReferenceDir>")
+)
+LOCAL_WEIGHTS_DIR = Path(
+    os.getenv("<FAMILY_UPPER>_LOCAL_WEIGHTS_DIR", REPO_ROOT / "official_weights" / FAMILY)
+)
+CONVERTED_WEIGHTS_DIR = Path(
+    os.getenv("<FAMILY_UPPER>_CONVERTED_WEIGHTS_DIR", REPO_ROOT / "converted_weights" / FAMILY)
+)
 
 
 def _resolve_hf_token() -> str | None:
@@ -93,14 +99,18 @@ def _load_official_model(device: torch.device, dtype: torch.dtype) -> torch.nn.M
     model = OfficialClass()  # TODO: pass official config kwargs.
     state_dict = {}  # TODO: load official state dict from LOCAL_WEIGHTS_DIR.
     missing, unexpected = model.load_state_dict(state_dict, strict=True)
-    assert not missing and not unexpected, (f"official load mismatch missing={missing[:5]} unexpected={unexpected[:5]}")
+    assert not missing and not unexpected, (
+        f"official load mismatch missing={missing[:5]} unexpected={unexpected[:5]}"
+    )
     return model.to(device=device, dtype=dtype).eval()
 
 
 def _load_fastvideo_model(device: torch.device, dtype: torch.dtype) -> torch.nn.Module:
     """Load the FastVideo component with the same tensor content."""
     if not CONVERTED_WEIGHTS_DIR.exists() and not LOCAL_WEIGHTS_DIR.exists():
-        pytest.skip(f"No FastVideo loadable weights: {CONVERTED_WEIGHTS_DIR} or {LOCAL_WEIGHTS_DIR}")
+        pytest.skip(
+            f"No FastVideo loadable weights: {CONVERTED_WEIGHTS_DIR} or {LOCAL_WEIGHTS_DIR}"
+        )
 
     # TODO: replace with the bucket-specific FastVideo config/class/loader.
     # DiT examples:
@@ -117,7 +127,8 @@ def _load_fastvideo_model(device: torch.device, dtype: torch.dtype) -> torch.nn.
     state_dict = {}  # TODO: load converted or directly mapped state dict.
     missing, unexpected = model.load_state_dict(state_dict, strict=True)
     assert not missing and not unexpected, (
-        f"FastVideo load mismatch missing={missing[:5]} unexpected={unexpected[:5]}")
+        f"FastVideo load mismatch missing={missing[:5]} unexpected={unexpected[:5]}"
+    )
     return model.to(device=device, dtype=dtype).eval()
 
 
@@ -176,9 +187,11 @@ def test_component_parity():
 
     assert official_out.shape == fastvideo_out.shape
     diff = (official_out - fastvideo_out).abs()
-    print(f"official abs_mean={official_out.abs().mean().item():.6f} "
-          f"fastvideo abs_mean={fastvideo_out.abs().mean().item():.6f} "
-          f"diff_max={diff.max().item():.6f} diff_mean={diff.mean().item():.6f}")
+    print(
+        f"official abs_mean={official_out.abs().mean().item():.6f} "
+        f"fastvideo abs_mean={fastvideo_out.abs().mean().item():.6f} "
+        f"diff_max={diff.max().item():.6f} diff_mean={diff.mean().item():.6f}"
+    )
 
     # TODO: pick tolerance by scope:
     # - single block / same kernel: 1e-4

.agents/skills/add-model-07-conversion/templates/family_to_diffusers.py

@@ -27,6 +27,7 @@ try:
 except ImportError:  # pragma: no cover - optional local conversion dependency
     snapshot_download = None
 
+
 # TODO: fill with authoritative component prefixes for monolithic checkpoints.
 # Example: {"model.model.": "transformer", "pretransform.model.": "vae"}
 COMPONENT_PREFIXES: dict[str, str] = {}
@@ -46,7 +47,10 @@ SKIP_PATTERNS: tuple[str, ...] = ()
 
 
 def _hf_token() -> str | None:
-    return (os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN") or os.environ.get("HF_API_KEY"))
+    return (
+        os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
+        or os.environ.get("HF_API_KEY")
+    )
 
 
 def resolve_src(src: str, revision: str | None) -> Path:
@@ -91,10 +95,11 @@ def apply_mapping(key: str) -> str | None:
     return key
 
 
-def split_monolithic(state: dict[str, torch.Tensor], ) -> dict[str, OrderedDict[str, torch.Tensor]]:
+def split_monolithic(
+    state: dict[str, torch.Tensor],
+) -> dict[str, OrderedDict[str, torch.Tensor]]:
     components: dict[str, OrderedDict[str, torch.Tensor]] = {
-        name: OrderedDict()
-        for name in set(COMPONENT_PREFIXES.values())
+        name: OrderedDict() for name in set(COMPONENT_PREFIXES.values())
     }
     intentionally_skipped: list[str] = []
     unowned: list[str] = []
@@ -112,8 +117,10 @@ def split_monolithic(state: dict[str, torch.Tensor], ) -> dict[str, OrderedDict[
             unowned.append(key)
     if unowned:
         sample = ", ".join(unowned[:10])
-        raise ValueError(f"Unowned monolithic keys: {len(unowned)}. "
-                         f"Add COMPONENT_PREFIXES or SKIP_PATTERNS entries. Sample: {sample}")
+        raise ValueError(
+            f"Unowned monolithic keys: {len(unowned)}. "
+            f"Add COMPONENT_PREFIXES or SKIP_PATTERNS entries. Sample: {sample}"
+        )
     if intentionally_skipped:
         print(f"Intentionally skipped {len(intentionally_skipped)} keys")
     return {name: weights for name, weights in components.items() if weights}
@@ -136,12 +143,8 @@ def build_component_configs(_src_dir: Path) -> dict[str, dict[str, Any]]:
     # TODO: emit config content accepted by FastVideo loaders. Most components use
     # config.json; schedulers use scheduler_config.json.
     return {
-        "transformer": {
-            "_class_name": "<FastVideoTransformerClass>"
-        },
-        "vae": {
-            "_class_name": "<FastVideoVAEClass>"
-        },
+        "transformer": {"_class_name": "<FastVideoTransformerClass>"},
+        "vae": {"_class_name": "<FastVideoVAEClass>"},
     }
 
 
@@ -174,13 +177,19 @@ def build_model_index(
     }
     if revision:
         index["_fastvideo_converted_revision"] = revision
-    return {key: value for key, value in index.items() if key.startswith("_") or key in available_components}
+    return {
+        key: value
+        for key, value in index.items()
+        if key.startswith("_") or key in available_components
+    }
 
 
 def validate_component_configs(configs: dict[str, dict[str, Any]]) -> None:
     # TODO: instantiate each FastVideo config and call update_model_arch(...) or
     # update_model_config(...) with this JSON so unknown emitted keys fail here.
-    placeholder_configs = [name for name, config in configs.items() if "<" in json.dumps(config)]
+    placeholder_configs = [
+        name for name, config in configs.items() if "<" in json.dumps(config)
+    ]
     if placeholder_configs:
         raise ValueError(f"Replace config placeholders for: {placeholder_configs}")
 
@@ -192,7 +201,9 @@ def verify_conversion(
     del dst_dir, components
     # TODO: load each emitted stateful component through its production loader and
     # assert strict load, or document exact allowed missing/unexpected keys.
-    raise NotImplementedError("Implement production config validation and strict-load checks")
+    raise NotImplementedError(
+        "Implement production config validation and strict-load checks"
+    )
 
 
 def write_component(
@@ -205,7 +216,9 @@ def write_component(
     if component_dir.exists() and any(component_dir.iterdir()):
         shutil.rmtree(component_dir)
     component_dir.mkdir(parents=True, exist_ok=True)
-    save_file(dict(state), str(component_dir / "diffusion_pytorch_model.safetensors"))
+    save_file(
+        dict(state), str(component_dir / "diffusion_pytorch_model.safetensors")
+    )
     if config is not None:
         config_path = component_dir / config_filename(name)
         with config_path.open("w", encoding="utf-8") as f:
@@ -248,7 +261,9 @@ def convert(
 
     if layout in {"monolithic", "raw_official"}:
         # TODO: replace model.safetensors with the official monolithic file name.
-        components = split_monolithic(load_checkpoint(default_monolithic_checkpoint(src_path)))
+        components = split_monolithic(
+            load_checkpoint(default_monolithic_checkpoint(src_path))
+        )
     elif layout in {"separate_components", "mixed"}:
         if not src_path.is_dir():
             raise ValueError(f"{layout} layout requires a source directory: {src_path}")
@@ -256,7 +271,9 @@ def convert(
     else:
         raise ValueError(f"Unsupported template layout: {layout}")
 
-    copied = (copy_passthrough(src_path, dst_dir) if src_path.is_dir() else [])
+    copied = (
+        copy_passthrough(src_path, dst_dir) if src_path.is_dir() else []
+    )
     configs = build_component_configs(src_path if src_path.is_dir() else src_path.parent)
     validate_component_configs(configs)
     for name, state in components.items():
@@ -272,7 +289,9 @@ def convert(
 
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--src", required=True, help="HF repo id, local dir, or checkpoint path")
+    parser.add_argument(
+        "--src", required=True, help="HF repo id, local dir, or checkpoint path"
+    )
     parser.add_argument("--revision", help="HF branch, tag, or commit for repo sources")
     parser.add_argument(
         "--dst",

.agents/skills/add-model-08-trace/templates/block_trace_debug.py

@@ -24,8 +24,8 @@ from typing import Any
 
 import torch
 
-FAMILY: str = "<family>"  # e.g. "magi_human", "ltx2", "wan"
-COMPONENT: str = "<component>"  # e.g. "dit", "vae", "encoder"
+FAMILY: str = "<family>"       # e.g. "magi_human", "ltx2", "wan"
+COMPONENT: str = "<component>" # e.g. "dit", "vae", "encoder"
 DRILL_LAYER_ENV: str = "<FAMILY>_DEBUG_DRILL_LAYER"
 HYPOTHESIS_ENV: str = "<FAMILY>_DEBUG_PATCH_<HYPOTHESIS>"
 REL_THRESHOLD: float = 0.005  # 0.5% abs_mean drift flags a block as divergent
@@ -94,7 +94,6 @@ def _attach_block_hooks(
     handles: list[Any] = []
 
     def _hook(name: str):
-
         def fn(_module, _inputs, outputs):
             t = outputs[0] if isinstance(outputs, tuple) else outputs
             if not torch.is_tensor(t):
@@ -102,7 +101,6 @@ def _attach_block_hooks(
             log.append({"side": label, **_stat(name, t)})
             if tensors is not None:
                 tensors[name] = t.detach().float().cpu()
-
         return fn
 
     def _pre_hook(name: str):
@@ -116,7 +114,6 @@ def _attach_block_hooks(
             log.append({"side": label, **_stat(key, t)})
             if tensors is not None:
                 tensors[key] = t.detach().float().cpu()
-
         return fn
 
     # TODO: adapt attribute paths to your model. Remove adapter block if absent.
@@ -134,21 +131,43 @@ def _attach_block_hooks(
             # magi-human uses: attention, mlp.pre_norm, mlp.up_gate_proj,
             # mlp.down_proj (pre+post), mlp, attn_post_norm, mlp_post_norm.
             if hasattr(layer, "attention"):
-                handles.append(layer.attention.register_forward_hook(_hook(f"{tag}.attention")))
+                handles.append(
+                    layer.attention.register_forward_hook(_hook(f"{tag}.attention"))
+                )
             if hasattr(layer, "mlp"):
                 mlp = layer.mlp
                 if hasattr(mlp, "pre_norm"):
-                    handles.append(mlp.pre_norm.register_forward_hook(_hook(f"{tag}.mlp.pre_norm")))
+                    handles.append(
+                        mlp.pre_norm.register_forward_hook(_hook(f"{tag}.mlp.pre_norm"))
+                    )
                 if hasattr(mlp, "up_gate_proj"):
-                    handles.append(mlp.up_gate_proj.register_forward_hook(_hook(f"{tag}.mlp.up_gate_proj")))
+                    handles.append(
+                        mlp.up_gate_proj.register_forward_hook(
+                            _hook(f"{tag}.mlp.up_gate_proj")
+                        )
+                    )
                 if hasattr(mlp, "down_proj"):
-                    handles.append(mlp.down_proj.register_forward_pre_hook(_pre_hook(f"{tag}.mlp.down_proj")))
-                    handles.append(mlp.down_proj.register_forward_hook(_hook(f"{tag}.mlp.down_proj")))
+                    handles.append(
+                        mlp.down_proj.register_forward_pre_hook(
+                            _pre_hook(f"{tag}.mlp.down_proj")
+                        )
+                    )
+                    handles.append(
+                        mlp.down_proj.register_forward_hook(_hook(f"{tag}.mlp.down_proj"))
+                    )
                 handles.append(mlp.register_forward_hook(_hook(f"{tag}.mlp")))
             if hasattr(layer, "attn_post_norm"):
-                handles.append(layer.attn_post_norm.register_forward_hook(_hook(f"{tag}.attn_post_norm")))
+                handles.append(
+                    layer.attn_post_norm.register_forward_hook(
+                        _hook(f"{tag}.attn_post_norm")
+                    )
+                )
             if hasattr(layer, "mlp_post_norm"):
-                handles.append(layer.mlp_post_norm.register_forward_hook(_hook(f"{tag}.mlp_post_norm")))
+                handles.append(
+                    layer.mlp_post_norm.register_forward_hook(
+                        _hook(f"{tag}.mlp_post_norm")
+                    )
+                )
     return handles
 
 
@@ -174,9 +193,11 @@ def _write_log(entries: list[dict], path: Path) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     with open(path, "w") as f:
         for e in entries:
-            f.write(f"{e['name']} {e['shape']} "
-                    f"{e['abs_mean']:.8f} {e['sum']:.4f} "
-                    f"{e['min']:.6f} {e['max']:.6f}\n")
+            f.write(
+                f"{e['name']} {e['shape']} "
+                f"{e['abs_mean']:.8f} {e['sum']:.4f} "
+                f"{e['min']:.6f} {e['max']:.6f}\n"
+            )
 
 
 def _sort_key(name: str, drill_layer: int) -> tuple:
@@ -184,14 +205,9 @@ def _sort_key(name: str, drill_layer: int) -> tuple:
         return (0, "")
     if name.startswith(f"L{drill_layer:02d}."):
         sub_order = {
-            "attention": 0,
-            "attn_post_norm": 1,
-            "mlp.pre_norm": 2,
-            "mlp.up_gate_proj": 3,
-            "mlp.down_proj<in>": 4,
-            "mlp.down_proj": 5,
-            "mlp": 6,
-            "mlp_post_norm": 7,
+            "attention": 0, "attn_post_norm": 1, "mlp.pre_norm": 2,
+            "mlp.up_gate_proj": 3, "mlp.down_proj<in>": 4,
+            "mlp.down_proj": 5, "mlp": 6, "mlp_post_norm": 7,
         }.get(name.split(".", 1)[1], 9)
         return (1, f"block[{drill_layer:02d}]", sub_order)
     if name.startswith("block["):
@@ -200,8 +216,10 @@ def _sort_key(name: str, drill_layer: int) -> tuple:
 
 
 def _print_table(by_name: dict[str, dict], drill_layer: int) -> int | None:
-    hdr = (f"{'name':<18} {'up_shape':<22} {'up_absmean':>12} {'fv_absmean':>12} "
-           f"{'absmean_diff':>14} {'rel%':>8} {'up_sum':>14} {'fv_sum':>14} {'sum_diff':>12}")
+    hdr = (
+        f"{'name':<18} {'up_shape':<22} {'up_absmean':>12} {'fv_absmean':>12} "
+        f"{'absmean_diff':>14} {'rel%':>8} {'up_sum':>14} {'fv_sum':>14} {'sum_diff':>12}"
+    )
     print(f"\n{hdr}\n{'-' * len(hdr)}")
     first_div: int | None = None
     for name in sorted(by_name.keys(), key=lambda n: _sort_key(n, drill_layer)):
@@ -217,9 +235,11 @@ def _print_table(by_name: dict[str, dict], drill_layer: int) -> int | None:
             flag = " <<< DIVERGE"
             if first_div is None:
                 first_div = int(name[len("block["):-1])
-        print(f"{name:<18} {str(up['shape']):<22} {up['abs_mean']:>12.6f} "
-              f"{fv['abs_mean']:>12.6f} {am_diff:>14.6f} {am_rel * 100:>7.3f}% "
-              f"{up['sum']:>14.4f} {fv['sum']:>14.4f} {sum_diff:>12.4f}{flag}")
+        print(
+            f"{name:<18} {str(up['shape']):<22} {up['abs_mean']:>12.6f} "
+            f"{fv['abs_mean']:>12.6f} {am_diff:>14.6f} {am_rel * 100:>7.3f}% "
+            f"{up['sum']:>14.4f} {fv['sum']:>14.4f} {sum_diff:>12.4f}{flag}"
+        )
     return first_div
 
 
@@ -235,8 +255,10 @@ def _print_elementwise(up_t: dict[str, torch.Tensor], fv_t: dict[str, torch.Tens
             continue
         diff = (a - b).abs()
         rel = (diff.mean().item() / max(a.abs().mean().item(), 1e-9)) * 100
-        print(f"{name:<30} {str(tuple(a.shape)):<22} "
-              f"{diff.max().item():>12.6f} {diff.mean().item():>12.6f} {rel:>9.4f}%")
+        print(
+            f"{name:<30} {str(tuple(a.shape)):<22} "
+            f"{diff.max().item():>12.6f} {diff.mean().item():>12.6f} {rel:>9.4f}%"
+        )
 
 
 def main() -> None:

.agents/skills/add-model-09-pipeline/templates/pipeline_parity_test.py

@@ -43,10 +43,12 @@ def _add_official_to_path() -> Path:
 
 def _log_tensor_stats(label: str, tensor: torch.Tensor) -> None:
     value = tensor.detach().float()
-    print(f"[{_MODEL_FAMILY} PIPELINE] {label}: shape={tuple(tensor.shape)} "
-          f"dtype={tensor.dtype} device={tensor.device} "
-          f"min={value.min().item():.6f} max={value.max().item():.6f} "
-          f"mean={value.mean().item():.6f} std={value.std().item():.6f}")
+    print(
+        f"[{_MODEL_FAMILY} PIPELINE] {label}: shape={tuple(tensor.shape)} "
+        f"dtype={tensor.dtype} device={tensor.device} "
+        f"min={value.min().item():.6f} max={value.max().item():.6f} "
+        f"mean={value.mean().item():.6f} std={value.std().item():.6f}"
+    )
 
 
 def _extract_tensor(output: Any, key: str) -> torch.Tensor:
@@ -71,8 +73,10 @@ def _run_official_pipeline(
     device: torch.device,
 ) -> Any:
     del official_path, params, device
-    pytest.skip("TODO: import the official pipeline/factory, load official weights, "
-                "run with params, and return the comparison target.")
+    pytest.skip(
+        "TODO: import the official pipeline/factory, load official weights, "
+        "run with params, and return the comparison target."
+    )
 
 
 def _run_fastvideo_pipeline(model_path: Path, params: dict[str, Any]) -> Any:
@@ -142,6 +146,8 @@ def test_todo_model_family_pipeline_official_parity() -> None:
     assert official_tensor.shape == fastvideo_tensor.shape
 
     diff = (official_tensor - fastvideo_tensor).abs()
-    print(f"diff max={diff.max().item():.6f} "
-          f"mean={diff.mean().item():.6f} median={diff.median().item():.6f}")
+    print(
+        f"diff max={diff.max().item():.6f} "
+        f"mean={diff.mean().item():.6f} median={diff.median().item():.6f}"
+    )
     assert_close(fastvideo_tensor, official_tensor, atol=1e-2, rtol=1e-2)

.agents/skills/ci-runner/SKILL.md

@@ -1,99 +0,0 @@
----
-name: ci-runner
-description: Work on FastVideo's Slurm-only, change-aware GPU CI lanes, static Buildkite graph, trusted ci-runner policy, lane scripts, and GB200 validation.
----
-
-# Slinky Slurm CI lanes
-
-FastVideo's `ci-runner` Buildkite queue is the control plane for all active
-GPU CI. A private host-owned dispatcher leases GPUs from the Slinky Slurm tray
-and runs the immutable PR SHA inside an isolated Enroot container. Buildkite
-pipeline upload and Slurm submission occur on the login plane; every test
-payload executes on Slurm compute.
-
-The files under `fastvideo/tests/modal/` and `.buildkite/scripts/pr_test.sh`
-are dormant rollback code. Never add an active Buildkite or slash-command
-route to them. `pr_test.sh` must continue to reject Buildkite invocations.
-
-The private operator bundle is deliberately outside this repository because
-it contains site paths and credentials. See
-`docs/contributing/ci_architecture.md`; this skill covers the repository half
-and the coordination contract with that bundle.
-
-## Invariants
-
-- `.buildkite/pipeline.yml` contains exactly one static step for every active
-  GPU lane. Each step pins a unique key and label, a 90-minute timeout, the
-  trusted `/opt/fastvideo-ci-runner/run-ci` command (`run-unit` is the one
-  compatibility wrapper), step-level internal `TEST_TYPE`, and
-  `queue: "ci-runner"`.
-- Active CI contains no `pr_test.sh` command, Modal invocation, default queue,
-  Buildkite plugin, `soft_fail`, or job-controlled artifact glob.
-- The six Fastcheck lanes use `:microscope:` labels. Full-Suite-only lanes use
-  `:test_tube:` or `:bar_chart:` so direct reruns update the right aggregate.
-- SSIM and vanilla training request all four GPUs. Keep both in the
-  `fastvideo/slinky/whole-tray` Buildkite concurrency group with a limit of one
-  so the second job does not consume an agent or command timeout while waiting
-  for the same tray.
-- `/test full` schedules all twenty lanes. `/merge`, `ready`, and new pushes to
-  ready PRs use the trusted base-branch planner in
-  `.github/scripts/plan_merge_ci.py`: automatic Fastcheck remains the universal
-  six-lane baseline, and the merge build adds only path-relevant integration
-  lanes. Unknown source/build paths fail closed to all fourteen additive lanes.
-  The trusted uploader still normalizes and validates the complete static graph
-  before Buildkite evaluates its plan conditions.
-- Focused merge builds may pass allowlisted golden-gate and SSIM test basenames.
-  The private host validates the lane plan and basenames before staging them,
-  and the in-container scripts validate them again. Direct `/test ssim`,
-  explicit `/test full`, and the weekly main-branch schedule run the complete
-  SSIM matrix.
-- The trusted uploader serves exactly three entry pipelines:
-  `pr-fastcheck` for automatic PR builds, `ci` for slash-command/ready-label
-  API builds, and `fastvideo-performance-lane` for the weekly schedule. Keep
-  incoming GitHub webhook processing disabled on `ci` so it cannot duplicate
-  `pr-fastcheck` on every PR update.
-- Test payloads live in `.buildkite/scripts/unit_test.sh` or executable
-  `.buildkite/scripts/lanes/<lane>.sh`. Backend policy (GPU count, extras,
-  secrets, kernel build, artifacts) stays in the agent-owned lane table.
-- Tests must preserve an inherited `MASTER_PORT`. Packed containers share the
-  tray network namespace, so the private runner assigns a distinct port range
-  per GPU lease and the SSIM scheduler assigns task offsets within its range.
-- The ARM64 runner image includes the pinned FA4 CuTe overlay validated on
-  GB200. Keep SSIM at `FASTVIDEO_FA4=1` because its references were seeded with
-  FA4; keep lanes with FA2 baselines at `FASTVIDEO_FA4=0`. A runner image change
-  must revalidate both the FA4 import and an actual GB200 forward kernel.
-- `fastvideo/tests/ssim/ci_runner.py` is the active four-GPU SSIM scheduler.
-  New SSIM files are discovered through `REQUIRED_GPUS` and
-  `*_MODEL_TO_PARAMS`; do not wire them through the dormant Modal scheduler.
-- The host policy fail-closes unknown tuples. A repository-side lane change is
-  inert until the operator updates the private lane table and uploader policy
-  in the same rollout.
-
-## Adding or changing a lane
-
-1. Read the closest `AGENTS.md` and the domain-specific testing guide.
-2. Add or update the executable lane payload under `.buildkite/scripts/`.
-   Keep it deterministic and free of host-specific paths or credential fetches.
-3. Add the static pipeline step and canonical `/test <name>` mapping. Keep the
-   `<name>-ci` alias only when compatibility requires it.
-4. Add its source/test path ownership to `.github/scripts/plan_merge_ci.py`.
-   Prefer the narrowest correctness-preserving lane set; leave unknown paths
-   fail-closed. Extend `fastvideo/tests/contract/test_ci_test_collection.py`,
-   `test_merge_ci_plan.py`, and focused CPU-only scheduler/policy tests.
-5. Coordinate the private lane row: GPU count (1-4), wall time, script, scope
-   pairs, step key, command, HF cache/token, tracking mode, extras, attention
-   backend policy, kernel policy, and artifact relay. Active training lanes
-   keep W&B offline and do not stage a W&B credential.
-6. Update the trusted pipeline-uploader schema. A mismatch must reject the
-   pipeline rather than silently skip a lane.
-7. Run `pre-commit run --files <changed paths>`, the planner's representative
-   diff matrix, contract tests, private driver tests, and a real GB200 canary.
-   Multi-GPU, hardware-reference, training, performance, and SSIM changes need
-   their own target-hardware evidence.
-
-## Rollback
-
-Rollback the Slurm routing/configuration change or pause the `ci-runner` queue.
-Do not silently reactivate Modal. A manual Modal experiment requires the
-explicit local opt-in documented in `ci_architecture.md`; returning it to
-production CI needs a separate reviewed decision.

.agents/skills/reseed-ssim-references/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: reseed-ssim-references
-description: Re-seed HF reference videos for a single existing SSIM test on Modal L40S. Always backs up current refs locally first, regenerates on Modal, pauses for the user to eyeball before-vs-after quality, then overwrites the targeted model subtree on `FastVideo/ssim-reference-videos` with `--force`. Use when an intentional code change (model port fix, attention backend swap, kernel upgrade, hyperparameter change) has invalidated existing refs and they need to be regenerated. Pairs with `seed-ssim-references`, which is for first-time seeding only.
+description: Re-seed HF reference videos for a single existing SSIM test on Modal L40S. Always backs up current refs locally first, regenerates on Modal, pauses for the user to eyeball before-vs-after quality, then overwrites the targeted `<model_id>` subtree on `FastVideo/ssim-reference-videos` with `--force`. Use when an intentional code change (model port fix, attention backend swap, kernel upgrade, hyperparameter change) has invalidated existing refs and they need to be regenerated. Pairs with `seed-ssim-references`, which is for first-time seeding only.
 ---
 
 # Re-seed SSIM Reference Videos
@@ -13,7 +13,7 @@ on HF — the old refs are overwritten — so the skill always:
 
 1. Confirms intent with a one-liner the user has to type.
 2. Downloads the existing refs as a local, timestamped backup.
-3. Regenerates through the manual legacy Modal L40S maintenance path.
+3. Regenerates on Modal L40S (same code path that CI uses).
 4. Pauses for a side-by-side eyeball of backup vs new mp4s.
 5. Uploads with `--force`, scoped to the single `--model-id`.
 6. Reminds the user to keep the backup until the PR lands.
@@ -51,9 +51,8 @@ harder to recover from than failing closed.
 
 Hardcoded:
 
-- Modal GPU: **L40S**. This is a manual reference-maintenance target, not the
-  active Slurm CI compute path; changing the SKU also changes the historical
-  `L40S_reference_videos` contract.
+- Modal GPU: **L40S** (matches CI; re-seeding from another SKU produces refs
+  that L40S CI cannot match).
 - Quality tier: **`default`**. `full_quality` is a separate, deliberate
   operation.
 - HF repo: `FastVideo/ssim-reference-videos` (override via

.agents/skills/seed-ssim-references/SKILL.md

@@ -35,8 +35,7 @@ The skill is run **manually**, once per new test. Before invoking it, the user
 has already sanity-tested the new test locally — it launches `VideoGenerator`
 and writes an artefact without crashing (the missing-reference assertion at
 the end is expected). The skill does not re-test locally; it goes straight
-to the manual legacy Modal L40S reference-maintenance target. Active CI runs
-on the Slinky Slurm cluster and only consumes the resulting references.
+to Modal L40S (which is what CI uses).
 
 ## When to use
 
@@ -62,8 +61,7 @@ Prompt the user for it if they didn't supply it.
 
 Everything else is fixed:
 
-- Modal maintenance GPU: **L40S** (hardcoded in
-  `fastvideo/tests/modal/ssim_test.py`; this is not the active CI compute path).
+- Modal runner GPU: **L40S** (hardcoded in `fastvideo/tests/modal/ssim_test.py`).
 - Device folder: `L40S_reference_videos`.
 - Quality tier: `default` (the tier CI runs). The `full_quality` tier is not
   seeded by this skill.

.buildkite/pipeline.yml

@@ -1,8 +1,7 @@
 env:
   IMAGE_VERSION: "py3.12-latest"
   BUILDKITE_CLEAN_CHECKOUT: true
-  # Slurm workers clone the immutable commit and initialize submodules inside
-  # their isolated container. The Buildkite login-plane checkout is a no-op.
+  # Buildkite only launches Modal; remote jobs initialize their own submodules.
   BUILDKITE_GIT_SUBMODULES: false
 
 notify:
@@ -11,458 +10,539 @@ notify:
     if: build.env("TEST_SCOPE") == "fastcheck" || build.env("TEST_SCOPE") == null
   - github_commit_status:
       context: "full-suite-passed"
-    if: build.env("TEST_SCOPE") == "full" || build.env("TEST_SCOPE") == "merge"
+    if: build.env("TEST_SCOPE") == "full"
   - github_commit_status:
       context: "direct-test-completed"
     if: build.env("TEST_SCOPE") == "direct"
-  - github_commit_status:
-      context: "scheduled-ssim-passed"
-    if: build.env("TEST_SCOPE") == "scheduled"
 
-# This is the complete active GPU CI surface. Every command is a trusted host
-# dispatcher, and every test payload executes inside the Slinky Slurm tray.
-# fastvideo/tests/modal remains available only for an explicit manual rollback;
-# no active pipeline or slash-command route invokes it.
 steps:
-  - label: ":microscope: Encoder Tests"
-    key: "encoder"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,encoder,/) ||
-      build.env("TEST_SCOPE") == "fastcheck" ||
-      build.env("TEST_SCOPE") == null ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "encoder" || build.env("TEST_TYPE") == "encoder_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "encoder_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
+  # ============================================================
+  # Direct test: triggered by /test <name> slash command.
+  # Labels match fastcheck/full-suite counterparts so the GitHub
+  # check status overwrites the original failed check.
+  # Only ONE step executes per build (gated by TEST_TYPE).
+  # ============================================================
 
-  - label: ":microscope: VAE Tests"
-    key: "vae"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,vae,/) ||
-      build.env("TEST_SCOPE") == "fastcheck" ||
-      build.env("TEST_SCOPE") == null ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "vae" || build.env("TEST_TYPE") == "vae_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "vae_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
+  # --- Fastcheck-scope direct tests ---
+    - label: ":microscope: Encoder Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "encoder"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":microscope: VAE Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "vae"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":microscope: Transformer Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "transformer"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":microscope: Kernel Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "kernel_tests"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":vertical_traffic_light: Golden-Gate Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "golden_gate"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":microscope: Unit Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "unit_test"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":microscope: DreamVerse App Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "dreamverse_app"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
 
-  - label: ":microscope: Transformer Tests"
-    key: "transformer"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,transformer,/) ||
-      build.env("TEST_SCOPE") == "fastcheck" ||
-      build.env("TEST_SCOPE") == null ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "transformer" || build.env("TEST_TYPE") == "transformer_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "transformer_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
+  # --- Full-suite-scope direct tests ---
+    - label: ":bar_chart: SSIM Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "ssim"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+          - exit_status: 1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: LoRA Inference Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "inference_lora"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: LoRA Extraction Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "lora_extraction"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: Training Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "training"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: Distillation DMD Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "distillation_dmd"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: Self-Forcing Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "self_forcing"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: LoRA Training Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "training_lora"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+          - exit_status: 1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: Training Tests VSA"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "training_vsa"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+          - exit_status: 1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: Inference Tests VMoBA"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "inference_vmoba"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: Performance Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "performance"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: API Server Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "api_server"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: Train Framework Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "train_framework"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
+    - label: ":test_tube: Eval Metrics Tests"
+      if: build.env("TEST_SCOPE") == "direct" && build.env("TEST_TYPE") == "eval"
+      command: "timeout 90m .buildkite/scripts/pr_test.sh"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      agents:
+        queue: "default"
 
-  - label: ":microscope: Kernel Tests"
-    key: "kernel-tests"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,kernel-tests,/) ||
-      build.env("TEST_SCOPE") == "fastcheck" ||
-      build.env("TEST_SCOPE") == null ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "kernel_tests" || build.env("TEST_TYPE") == "kernel_tests_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "kernel_tests_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
+  # ============================================================
+  # Fastcheck: Runs on every PR (~10-15 min parallel)
+  # Core component validation: encoders, VAEs, transformers,
+  # CUDA kernels, and unit tests.
+  # ============================================================
+    - label: "Trigger Fastcheck"
+      if: build.env("TEST_SCOPE") == "fastcheck" || build.env("TEST_SCOPE") == null
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      plugins:
+        - monorepo-diff#v1.4.0:
+            diff: 'git fetch origin "${BUILDKITE_PULL_REQUEST_BASE_BRANCH:-main}" && git diff --name-only "origin/${BUILDKITE_PULL_REQUEST_BASE_BRANCH:-main}...HEAD"'
+            watch:
+            - path:
+                - "fastvideo/models/encoders/**"
+                - "fastvideo/models/loader/**"
+                - "fastvideo/tests/encoders/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 20m .buildkite/scripts/pr_test.sh"
+                label: ":microscope: Encoder Tests"
+                env:
+                  - TEST_TYPE=encoder
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/models/vaes/**"
+                - "fastvideo/models/loader/**"
+                - "fastvideo/tests/vaes/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 20m .buildkite/scripts/pr_test.sh"
+                label: ":microscope: VAE Tests"
+                env:
+                  - TEST_TYPE=vae
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/models/dits/**"
+                - "fastvideo/models/loader/**"
+                - "fastvideo/tests/transformers/**"
+                - "fastvideo/layers/**"
+                - "fastvideo/attention/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 15m .buildkite/scripts/pr_test.sh"
+                label: ":microscope: Transformer Tests"
+                env:
+                  - TEST_TYPE=transformer
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo-kernel/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 15m .buildkite/scripts/pr_test.sh"
+                label: ":microscope: Kernel Tests"
+                env:
+                  - TEST_TYPE=kernel_tests
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/**"
+                - ".buildkite/**"
+                - ".github/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 15m .buildkite/scripts/pr_test.sh"
+                label: ":microscope: Unit Tests"
+                env:
+                  - TEST_TYPE=unit_test
+                agents:
+                  queue: "default"
+            - path:
+                - "apps/dreamverse/**"
+                - "pyproject.toml"
+              config:
+                command: "timeout 30m .buildkite/scripts/pr_test.sh"
+                label: ":microscope: DreamVerse App Tests"
+                env:
+                  - TEST_TYPE=dreamverse_app
+                agents:
+                  queue: "default"
 
-  - label: ":microscope: Unit Tests"
-    key: "unit"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,unit,/) ||
-      build.env("TEST_SCOPE") == "fastcheck" ||
-      build.env("TEST_SCOPE") == null ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "unit_test" || build.env("TEST_TYPE") == "unit_test_ci"))
-    command: "/opt/fastvideo-ci-runner/run-unit"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "unit_test_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":microscope: DreamVerse App Tests"
-    key: "dreamverse"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,dreamverse,/) ||
-      build.env("TEST_SCOPE") == "fastcheck" ||
-      build.env("TEST_SCOPE") == null ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "dreamverse_app" || build.env("TEST_TYPE") == "dreamverse_app_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "dreamverse_app_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: Golden-Gate Tests"
-    key: "golden-gate"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,golden-gate,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "golden_gate" || build.env("TEST_TYPE") == "golden_gate_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "golden_gate_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":bar_chart: SSIM Tests"
-    key: "ssim"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      build.env("TEST_SCOPE") == "scheduled" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,ssim,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "ssim" || build.env("TEST_TYPE") == "ssim_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    concurrency: 1
-    concurrency_group: "fastvideo/slinky/whole-tray"
-    env:
-      TEST_TYPE: "ssim_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-        - exit_status: 1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: LoRA Inference Tests"
-    key: "lora-inference"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,lora-inference,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "inference_lora" || build.env("TEST_TYPE") == "inference_lora_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "inference_lora_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: LoRA Extraction Tests"
-    key: "lora-extraction"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,lora-extraction,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "lora_extraction" || build.env("TEST_TYPE") == "lora_extraction_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "lora_extraction_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: Training Tests"
-    key: "training"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,training,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "training" || build.env("TEST_TYPE") == "training_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    concurrency: 1
-    concurrency_group: "fastvideo/slinky/whole-tray"
-    env:
-      TEST_TYPE: "training_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: Distillation DMD Tests"
-    key: "distillation"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,distillation,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "distillation_dmd" || build.env("TEST_TYPE") == "distillation_dmd_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "distillation_dmd_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: Self-Forcing Tests"
-    key: "self-forcing"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,self-forcing,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "self_forcing" || build.env("TEST_TYPE") == "self_forcing_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "self_forcing_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: LoRA Training Tests"
-    key: "lora-training"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,lora-training,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "training_lora" || build.env("TEST_TYPE") == "training_lora_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "training_lora_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-        - exit_status: 1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: Training Tests VSA"
-    key: "training-vsa"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,training-vsa,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "training_vsa" || build.env("TEST_TYPE") == "training_vsa_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "training_vsa_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-        - exit_status: 1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: Inference Tests VMoBA"
-    key: "inference-vmoba"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,inference-vmoba,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "inference_vmoba" || build.env("TEST_TYPE") == "inference_vmoba_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "inference_vmoba_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: Performance Tests"
-    key: "performance"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,performance,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "performance" || build.env("TEST_TYPE") == "performance_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "performance_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: API Server Tests"
-    key: "api-server"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,api-server,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "api_server" || build.env("TEST_TYPE") == "api_server_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "api_server_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: Train Framework Tests"
-    key: "train-framework"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,train-framework,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "train_framework" || build.env("TEST_TYPE") == "train_framework_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "train_framework_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
-
-  - label: ":test_tube: Eval Metrics Tests"
-    key: "eval"
-    if: |
-      build.env("TEST_SCOPE") == "full" ||
-      (build.env("TEST_SCOPE") == "merge" &&
-       build.env("MERGE_TEST_PLAN") =~ /,eval,/) ||
-      (build.env("TEST_SCOPE") == "direct" &&
-       (build.env("TEST_TYPE") == "eval" || build.env("TEST_TYPE") == "eval_ci"))
-    command: "/opt/fastvideo-ci-runner/run-ci"
-    timeout_in_minutes: 90
-    env:
-      TEST_TYPE: "eval_ci"
-    retry:
-      automatic:
-        - exit_status: 128
-          limit: 3
-        - exit_status: -1
-          limit: 2
-    agents:
-      queue: "ci-runner"
+  # ============================================================
+  # Full Suite: Runs when TEST_SCOPE=full
+  # Triggered by adding the 'ready' label (via ci-trigger-full-suite.yml)
+  # or on-demand via /test full slash command.
+  # Includes integration tests, SSIM regression, training pipelines,
+  # and performance benchmarks.
+  # ============================================================
+    - label: "Trigger Full Suite"
+      if: build.env("TEST_SCOPE") == "full"
+      retry:
+        automatic:
+          - exit_status: 128
+            limit: 3
+          - exit_status: -1
+            limit: 2
+      plugins:
+        - monorepo-diff#v1.4.0:
+            diff: 'git fetch origin "${BUILDKITE_PULL_REQUEST_BASE_BRANCH:-main}" && git diff --name-only "origin/${BUILDKITE_PULL_REQUEST_BASE_BRANCH:-main}...HEAD"'
+            watch:
+            - path:
+                - "fastvideo/**/*.py"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 90m .buildkite/scripts/pr_test.sh"
+                label: ":bar_chart: SSIM Tests"
+                env:
+                  - TEST_TYPE=ssim
+                retry:
+                  automatic:
+                    - exit_status: 1
+                      limit: 2
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/tests/lora/**"
+                - "fastvideo/models/loader/**"
+                - "fastvideo/tests/transformers/**"
+                - "fastvideo/pipelines/**"
+                - "fastvideo/layers/lora/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 20m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: LoRA Inference Tests"
+                env:
+                  - TEST_TYPE=inference_lora
+                agents:
+                  queue: "default"
+            - path:
+                - "scripts/lora_extraction/**"
+                - "fastvideo/tests/lora_extraction/**"
+                - "fastvideo/models/loader/**"
+                - "fastvideo/training/training_utils.py"
+                - "fastvideo/layers/lora/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 90m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: LoRA Extraction Tests"
+                env:
+                  - TEST_TYPE=lora_extraction
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 25m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: Training Tests"
+                env:
+                  - TEST_TYPE=training
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/training/*distillation_pipeline.py"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 25m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: Distillation DMD Tests"
+                env:
+                  - TEST_TYPE=distillation_dmd
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/training/*self_forcing_distillation_pipeline.py"
+                - "fastvideo/tests/training/self-forcing/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 30m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: Self-Forcing Tests"
+                env:
+                  - TEST_TYPE=self_forcing
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 25m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: LoRA Training Tests"
+                env:
+                  - TEST_TYPE=training_lora
+                retry:
+                  automatic:
+                    - exit_status: 1
+                      limit: 2
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/**"
+                - "fastvideo-kernel/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 15m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: Training Tests VSA"
+                env:
+                  - TEST_TYPE=training_vsa
+                retry:
+                  automatic:
+                    - exit_status: 1
+                      limit: 2
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo-kernel/**"
+                - "fastvideo/attention/backends/vmoba.py"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 15m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: Inference Tests VMoBA"
+                env:
+                  - TEST_TYPE=inference_vmoba
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/models/dits/**"
+                - "fastvideo/pipelines/**"
+                - "fastvideo/attention/**"
+                - "fastvideo/layers/**"
+                - "fastvideo/worker/**"
+                - "fastvideo/entrypoints/**"
+                - "fastvideo/performance/**"
+                - "fastvideo/tests/performance/**"
+                - ".buildkite/performance-benchmarks/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 30m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: Performance Tests"
+                env:
+                  - TEST_TYPE=performance
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/entrypoints/openai/**"
+                - "fastvideo/entrypoints/cli/serve.py"
+                - "fastvideo/tests/entrypoints/test_openai_api_integration.py"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 30m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: API Server Tests"
+                env:
+                  - TEST_TYPE=api_server
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/train/**"
+                - "fastvideo/tests/train/models/**"
+                - "fastvideo/tests/train/fixtures/**"
+                - "fastvideo/models/dits/**"
+                - "fastvideo/models/loader/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 30m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: Train Framework Tests"
+                env:
+                  - TEST_TYPE=train_framework
+                agents:
+                  queue: "default"
+            - path:
+                - "fastvideo/eval/**"
+                - "fastvideo/tests/eval/**"
+                - "pyproject.toml"
+                - "docker/Dockerfile"
+              config:
+                command: "timeout 90m .buildkite/scripts/pr_test.sh"
+                label: ":test_tube: Eval Metrics Tests"
+                env:
+                  - TEST_TYPE=eval
+                agents:
+                  queue: "default"

.buildkite/scripts/lanes/api_server.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the OpenAI-compatible API lane.
-set -euo pipefail
-
-exec pytest ./fastvideo/tests/entrypoints/test_openai_api_integration.py -vs

.buildkite/scripts/lanes/distillation_dmd.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the distillation-DMD lane.
-set -euo pipefail
-
-exec pytest ./fastvideo/tests/training/distill/test_distill_dmd.py -vs

.buildkite/scripts/lanes/dreamverse.sh

@@ -1,87 +0,0 @@
-#!/usr/bin/env bash
-# DreamVerse needs a GPU for import-time device resolution, but it does not
-# build or exercise fastvideo-kernel. A checksummed Node archive is installed
-# in the disposable Slurm container because the shared CI image is
-# Python/CUDA focused.
-set -euo pipefail
-
-node_version=v22.23.2
-case $(uname -m) in
-  aarch64 | arm64)
-    node_arch=arm64
-    node_archive_sha256=013b59cfd2819703a6f4a14ab891fc46fc2a4e3f5bcd92de3fb4929b43e35b30
-    ;;
-  x86_64 | amd64)
-    node_arch=x64
-    node_archive_sha256=b294a556e639d64338823920e5866c21c02741742d2e1529ee1a225c1ec9252a
-    ;;
-  *)
-    echo "Unsupported architecture for DreamVerse Node runtime: $(uname -m)" >&2
-    exit 2
-    ;;
-esac
-node_archive="node-${node_version}-linux-${node_arch}.tar.gz"
-node_runtime_root=$(mktemp -d -t fastvideo-node.XXXXXX)
-node_archive_path="${node_runtime_root}/${node_archive}"
-node_install_dir="${node_runtime_root}/${node_archive%.tar.gz}"
-curl --proto '=https' --tlsv1.2 --retry 5 --retry-all-errors \
-  --location --fail --silent --show-error \
-  "https://nodejs.org/dist/${node_version}/${node_archive}" \
-  --output "$node_archive_path"
-printf '%s  %s\n' "$node_archive_sha256" "$node_archive_path" | sha256sum --check --status
-tar -xzf "$node_archive_path" -C "$node_runtime_root"
-export PATH="${node_install_dir}/bin:${PATH}"
-node --version
-npm --version
-
-export PYTHONPATH="$(pwd)/apps/dreamverse${PYTHONPATH:+:$PYTHONPATH}"
-pytest apps/dreamverse/dreamverse/tests -q
-
-cd apps/dreamverse/web
-npm ci
-npm run typecheck
-npm test
-machine_arch=$(uname -m)
-if [[ $machine_arch =~ ^(aarch64|arm64)$ ]]; then
-  npx playwright install --with-deps chromium firefox
-else
-  npx playwright install --with-deps chromium webkit firefox
-fi
-
-master_port=${MASTER_PORT:-7959}
-BACKEND_PORT=${BACKEND_PORT:-$((master_port + 50))}
-python -m uvicorn dreamverse.mock_server:app --host 127.0.0.1 --port "$BACKEND_PORT" &
-mock_server_pid=$!
-cleanup() {
-  kill "$mock_server_pid" 2>/dev/null || true
-  wait "$mock_server_pid" 2>/dev/null || true
-}
-trap cleanup EXIT INT TERM
-
-for _ in {1..30}; do
-  curl -fsS "http://127.0.0.1:$BACKEND_PORT/healthz" && break
-  sleep 1
-done
-curl -fsS "http://127.0.0.1:$BACKEND_PORT/healthz"
-
-if [[ $machine_arch =~ ^(aarch64|arm64)$ ]]; then
-  # Playwright WebKit traps before opening a page on Linux ARM64, and its
-  # bundled Chromium lacks the H.264/AAC codecs used by the fMP4 assertions.
-  # Firefox covers every flow, including streaming. Chromium and its mobile
-  # profile still cover all codec-independent UI behavior on GB200.
-  BACKEND_HOST=127.0.0.1 BACKEND_PORT="$BACKEND_PORT" CI=1 \
-    npm run e2e -- --project=firefox
-  BACKEND_HOST=127.0.0.1 BACKEND_PORT="$BACKEND_PORT" CI=1 \
-    npm run e2e -- \
-      --project=chromium \
-      --project=mobile-chromium \
-      --grep-invert='streams, plays, and surfaces a downloadable clip|starts a new project and switches back to the prior session|saved projects persist across a page reload'
-else
-  BACKEND_HOST=127.0.0.1 BACKEND_PORT="$BACKEND_PORT" CI=1 \
-    npm run e2e -- \
-      --project=chromium \
-      --project=webkit \
-      --project=firefox \
-      --project=mobile-safari \
-      --project=mobile-chromium
-fi

.buildkite/scripts/lanes/encoder.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the encoder lane.
-set -euo pipefail
-
-exec pytest ./fastvideo/tests/encoders -vs

.buildkite/scripts/lanes/eval.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the evaluation lane.
-set -euo pipefail
-
-exec pytest ./fastvideo/tests/eval -vs

.buildkite/scripts/lanes/golden_gate.sh

@@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the golden-gate lane. Environment (HF_HOME
-# and authentication) is the runner's responsibility.
-set -euo pipefail
-
-golden_root=./fastvideo/tests/golden_gate
-selected=${FASTVIDEO_GOLDEN_TEST_FILES-}
-if [ -z "$selected" ]; then
-  if [ "${TEST_SCOPE:-}" = merge ]; then
-    echo "Missing FASTVIDEO_GOLDEN_TEST_FILES for merge scope" >&2
-    exit 2
-  fi
-  selected=all
-fi
-if [ "$selected" = all ]; then
-  exec pytest "$golden_root" -vs
-fi
-
-[[ $selected =~ ^test_[a-z0-9_]+\.py(,test_[a-z0-9_]+\.py)*$ ]] || {
-  echo "Invalid FASTVIDEO_GOLDEN_TEST_FILES selection" >&2
-  exit 2
-}
-
-IFS=, read -r -a golden_files <<< "$selected"
-golden_paths=()
-for golden_file in "${golden_files[@]}"; do
-  golden_path="$golden_root/$golden_file"
-  [ -f "$golden_path" ] || {
-    echo "Selected golden test does not exist: $golden_file" >&2
-    exit 2
-  }
-  golden_paths+=("$golden_path")
-done
-
-exec pytest "${golden_paths[@]}" -vs

.buildkite/scripts/lanes/inference_lora.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the LoRA-inference lane.
-set -euo pipefail
-
-exec pytest ./fastvideo/tests/inference/lora/test_lora_inference_similarity.py -vs

.buildkite/scripts/lanes/inference_vmoba.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the VMoBA-inference lane.
-set -euo pipefail
-
-exec python fastvideo/tests/inference/vmoba/test_vmoba_inference.py

.buildkite/scripts/lanes/kernel_tests.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the custom-kernel lane.
-set -euo pipefail
-
-exec pytest fastvideo-kernel/tests/ -vs

.buildkite/scripts/lanes/lora_extraction.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the LoRA-extraction lane.
-set -euo pipefail
-
-exec pytest ./fastvideo/tests/lora_extraction/test_lora_extraction.py -vs

.buildkite/scripts/lanes/performance.sh

@@ -1,52 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm performance lane. Reports are written outside the checkout
-# so the trusted host driver can upload them after untrusted code exits.
-set -uo pipefail
-
-export PERFORMANCE_TRACKING_ROOT=/tmp/perf-tracking
-export PERF_REPORTS_DIR=/workspace/artifacts/performance
-mkdir -p "$PERF_REPORTS_DIR"
-
-if [[ ${BUILDKITE_PULL_REQUEST:-false} =~ ^[1-9][0-9]*$ ]]; then
-  export PERF_RUN_SOURCE=pr
-  export PERF_UPLOAD_POLICY=pass
-elif [ "${BUILDKITE_BRANCH:-}" = main ] \
-  && { [ "${BUILDKITE_SOURCE:-}" = schedule ] || [ "${TEST_SCOPE:-}" = full ]; }; then
-  export PERF_RUN_SOURCE=scheduled_main
-  export PERF_UPLOAD_POLICY=always
-elif [ "${TEST_SCOPE:-}" = direct ]; then
-  export PERF_RUN_SOURCE=unknown
-  export PERF_UPLOAD_POLICY=pass
-else
-  export PERF_RUN_SOURCE=unknown
-  export PERF_UPLOAD_POLICY=never
-fi
-
-nvidia-smi \
-  --query-gpu=index,timestamp,clocks.sm,clocks.max.sm,power.draw,power.limit,temperature.gpu \
-  --format=csv -l 10 > "$PERF_REPORTS_DIR/gpu_telemetry.csv" 2>/dev/null &
-telemetry_pid=$!
-cleanup() {
-  kill "$telemetry_pid" 2>/dev/null || true
-  wait "$telemetry_pid" 2>/dev/null || true
-}
-trap cleanup EXIT INT TERM
-
-pytest ./fastvideo/tests/performance -vs
-pytest_rc=$?
-compare_rc=0
-if [ "$pytest_rc" -eq 0 ] || [ "$PERF_UPLOAD_POLICY" = always ]; then
-  PERF_PYTEST_RC=$pytest_rc python ./fastvideo/tests/performance/compare_baseline.py
-  compare_rc=$?
-fi
-python ./fastvideo/tests/performance/dashboard.py || true
-cp -f fastvideo/tests/performance/results/*.json "$PERF_REPORTS_DIR/" 2>/dev/null || true
-
-echo "--- GPU telemetry (clocks.sm vs clocks.max.sm reveals capped hosts) ---"
-cat "$PERF_REPORTS_DIR/gpu_telemetry.csv" || true
-
-final_rc=$pytest_rc
-if [ "$final_rc" -eq 0 ]; then
-  final_rc=$compare_rc
-fi
-exit "$final_rc"

.buildkite/scripts/lanes/self_forcing.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the self-forcing lane.
-set -euo pipefail
-
-export WANDB_MODE=offline
-exec pytest ./fastvideo/tests/training/self-forcing/test_self_forcing.py -vs

.buildkite/scripts/lanes/ssim.sh

@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-# Canonical four-GPU SSIM lane for the Slinky Slurm worker.
-set -euo pipefail
-
-args=()
-if [ "${FASTVIDEO_SSIM_BOOTSTRAP_MODE:-0}" = 1 ]; then
-  args+=(--bootstrap-mode)
-fi
-selected=${FASTVIDEO_SSIM_TEST_FILES-}
-if [ -z "$selected" ]; then
-  if [ "${TEST_SCOPE:-}" = merge ]; then
-    echo "Missing FASTVIDEO_SSIM_TEST_FILES for merge scope" >&2
-    exit 2
-  fi
-  selected=all
-fi
-if [ "$selected" != all ]; then
-  [[ $selected =~ ^test_[a-z0-9_]+\.py(,test_[a-z0-9_]+\.py)*$ ]] || {
-    echo "Invalid FASTVIDEO_SSIM_TEST_FILES selection" >&2
-    exit 2
-  }
-  IFS=, read -r -a ssim_files <<< "$selected"
-  for ssim_file in "${ssim_files[@]}"; do
-    args+=(--test-file "$ssim_file")
-  done
-fi
-
-# MoGe's utils3d dependency builds glcontext from source on ARM64. The current
-# runner image predates the baked-in X11 headers below, so keep this guarded
-# bootstrap until every deployed image digest contains libx11-dev.
-if [ ! -f /usr/include/X11/Xlib.h ]; then
-  apt-get -o Acquire::Retries=5 update
-  apt-get -o Acquire::Retries=5 install -y --no-install-recommends libx11-dev
-  rm -rf /var/lib/apt/lists/*
-fi
-
-uv pip install git+https://github.com/microsoft/MoGe.git
-uv pip install k_diffusion einops_exts alias_free_torch torchsde
-
-exec python fastvideo/tests/ssim/ci_runner.py "${args[@]}"

.buildkite/scripts/lanes/train_framework.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the modular training-framework lane.
-set -euo pipefail
-
-exec pytest ./fastvideo/tests/train/models ./fastvideo/tests/train/methods -vs

.buildkite/scripts/lanes/training.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the legacy vanilla-training lane.
-set -euo pipefail
-
-export WANDB_MODE=offline
-exec pytest ./fastvideo/tests/training/Vanilla -srP

.buildkite/scripts/lanes/training_lora.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the legacy LoRA-training lane.
-set -euo pipefail
-
-export WANDB_MODE=offline
-exec pytest ./fastvideo/tests/training/lora/test_lora_training.py -srP

.buildkite/scripts/lanes/training_vsa.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the legacy VSA-training lane.
-set -euo pipefail
-
-export WANDB_MODE=offline
-exec pytest ./fastvideo/tests/training/VSA -srP

.buildkite/scripts/lanes/transformer.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the transformer lane.
-set -euo pipefail
-
-exec pytest ./fastvideo/tests/transformers -vs

.buildkite/scripts/lanes/vae.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Canonical Slurm CI selection for the VAE lane.
-set -euo pipefail
-
-exec pytest ./fastvideo/tests/vaes -vs

.buildkite/scripts/pr_test.sh

@@ -1,19 +1,6 @@
 #!/bin/bash
 set -uo pipefail
 
-# DORMANT ROLLBACK ONLY. Active CI is Slurm-only and pipeline.yml never calls
-# this launcher. Refuse every Buildkite invocation even if a stale step or
-# operator typo reaches this file; local rollback experiments require an
-# explicit opt-in.
-if [ -n "${BUILDKITE:-}" ]; then
-  echo "Legacy Modal CI is disabled; use the Slinky Slurm runner." >&2
-  exit 2
-fi
-if [ "${FASTVIDEO_ENABLE_LEGACY_MODAL_CI:-0}" != 1 ]; then
-  echo "Legacy Modal CI is dormant. Set FASTVIDEO_ENABLE_LEGACY_MODAL_CI=1 only for a manual rollback test." >&2
-  exit 2
-fi
-
 log() {
   echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
 }

.buildkite/scripts/unit_test.sh

@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-exec pytest \
-  ./fastvideo/tests/api/ \
-  ./fastvideo/tests/contract/ \
-  ./fastvideo/tests/dataset/ \
-  ./fastvideo/tests/workflow/ \
-  ./fastvideo/tests/entrypoints/ \
-  ./fastvideo/tests/loader/ \
-  ./fastvideo/tests/pipelines/ \
-  ./fastvideo/tests/platforms/ \
-  ./fastvideo/tests/train/ \
-  ./fastvideo/tests/stages/ \
-  ./fastvideo/tests/ops/ \
-  ./fastvideo/tests/worker/ \
-  ./fastvideo/tests/training/test_trackers.py \
-  ./fastvideo/tests/attention/test_sdpa_metadata_mask_contract.py \
-  ./fastvideo/tests/modal/test_kernel_build_cache.py \
-  ./fastvideo/tests/modal/test_pr_test.py \
-  ./fastvideo/tests/modal/test_ssim_test.py \
-  --ignore=./fastvideo/tests/entrypoints/test_openai_api_integration.py \
-  --ignore=./fastvideo/tests/train/models \
-  --ignore=./fastvideo/tests/train/methods \
-  -vs

.github/PULL_REQUEST_TEMPLATE.md

@@ -8,10 +8,10 @@ PR TITLE: Must start with a type tag, e.g.:
 MERGE WORKFLOW:
   1. Ensure pre-commit passes and you have at least 1 approval
   2. Comment /merge (or add the "ready" label) to enter the Merge Queue
-  3. A path-aware merge gate runs only relevant integration tests → auto-merge on success
+  3. Full Test Suite runs automatically on a staging branch → auto-merge on success
 
 ON-DEMAND TESTING (write access required):
-  /test full       — Explicit all-lane run  /test ssim        — Full SSIM regression
+  /test full       — Full Test Suite        /test ssim        — SSIM regression
   /test training   — Training pipeline      /test encoder     — Encoder tests
   /test transformer — Transformer tests     /test vae         — VAE tests
   /test kernel     — CUDA kernel tests      /test unit        — Unit tests

.github/scripts/gate_full_suite.sh

@@ -1,14 +1,14 @@
 #!/usr/bin/env bash
-# Gate the path-aware Buildkite merge plan on the cheap GitHub checks.
+# Gate the expensive Buildkite full suite on the cheap GitHub checks.
 #
 # Polls the workflow runs for the PR head commit and only exits 0 once the
 # watched cheap workflows (pre-commit, docs build) have succeeded, so the
-# 'ready' label cannot burn path-selected GPU lanes on a head that a cheap
-# check has already doomed.
+# 'ready' label cannot burn ~20 GPU lanes on a head that a cheap check has
+# already doomed.
 #
 # Semantics:
 #   - watched run completed with a bad conclusion  -> exit 1 (fail CLOSED:
-#     no merge gate; the next push re-arms via the 'synchronize' trigger)
+#     no full suite; the next push re-arms via the 'synchronize' trigger)
 #   - watched run cancelled                         -> still pending: the docs
 #     workflow's repo-global 'pages' concurrency group cancels runs superseded
 #     by unrelated pushes, so 'cancelled' is not a verdict on this PR
@@ -29,7 +29,7 @@ set -euo pipefail
 : "${PR_NUMBER:?PR_NUMBER (pull request number) is required}"
 : "${GITHUB_REPOSITORY:?GITHUB_REPOSITORY is required}"
 
-# Workflow-level `name:` values that must be green before the merge gate
+# Workflow-level `name:` values that must be green before the full suite
 # may start. "Deploy Documentation" is path-filtered on PRs, so its run may
 # legitimately never exist; pre-commit always runs, so it must appear.
 WATCHED_NAMES='["pre-commit", "Deploy Documentation"]'
@@ -56,7 +56,7 @@ recheck_ready_label() {
   if pr_json=$(gh_api "repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}" 2>/dev/null); then
     if ! jq -e '[.labels[]?.name] | index("ready")' <<<"$pr_json" >/dev/null 2>&1; then
       echo "::error::PR #${PR_NUMBER} no longer has the 'ready' label —" \
-        "NOT triggering the Buildkite merge gate. Re-add the label to re-arm."
+        "NOT triggering the Buildkite full suite. Re-add the label to re-arm."
       exit 1
     fi
   else
@@ -84,7 +84,7 @@ while true; do
         | map(.name) | join(", ")' <<<"$state")
     if [ -n "$failed" ]; then
       echo "::error::Cheap check(s) failed on ${PR_SHA}: ${failed}." \
-        "NOT triggering the Buildkite merge gate. Push a fix (the 'ready'" \
+        "NOT triggering the Buildkite full suite. Push a fix (the 'ready'" \
         "label re-arms on every push), or re-run the failed check and then" \
         "re-run this workflow."
       exit 1
@@ -97,7 +97,7 @@ while true; do
     if [ "$pending" -eq 0 ]; then
       if [ -z "$missing" ]; then
         recheck_ready_label
-        echo "All watched cheap checks are green — merge gate may proceed."
+        echo "All watched cheap checks are green — full suite may proceed."
         exit 0
       fi
       case "$missing" in
@@ -119,14 +119,14 @@ while true; do
     echo "::warning::GitHub API error querying workflow runs for ${PR_SHA} (attempt ${api_fails}/3)."
     if [ "$api_fails" -ge 3 ]; then
       recheck_ready_label
-      echo "::warning::FAILING OPEN: cannot query GitHub check status — triggering the merge gate WITHOUT the cheap-check gate."
+      echo "::warning::FAILING OPEN: cannot query GitHub check status — triggering the full suite WITHOUT the cheap-check gate."
       exit 0
     fi
   fi
 
   if [ "$elapsed" -ge "$MAX_WAIT_SECS" ]; then
     recheck_ready_label
-    echo "::warning::FAILING OPEN: watched checks still pending after $(( MAX_WAIT_SECS / 60 )) min${missing:+ (never appeared: ${missing})} — triggering the merge gate anyway."
+    echo "::warning::FAILING OPEN: watched checks still pending after $(( MAX_WAIT_SECS / 60 )) min${missing:+ (never appeared: ${missing})} — triggering the full suite anyway."
     exit 0
   fi
   sleep "$POLL_SECS"

.github/scripts/plan_merge_ci.py

@@ -1,570 +0,0 @@
-#!/usr/bin/env python3
-"""Select the additive GPU integration lanes needed by a PR diff.
-
-Fastcheck is the universal six-lane baseline and is intentionally not repeated
-here.  This planner selects only the more expensive merge-gate lanes.  Unknown
-source/build paths fail closed to the complete integration set, while explicit
-documentation and repository-metadata paths require no additional GPU work.
-"""
-
-from __future__ import annotations
-
-import argparse
-import fnmatch
-import re
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import TextIO
-
-MERGE_LANES = (
-    "golden-gate",
-    "ssim",
-    "lora-inference",
-    "lora-extraction",
-    "training",
-    "distillation",
-    "self-forcing",
-    "lora-training",
-    "training-vsa",
-    "inference-vmoba",
-    "performance",
-    "api-server",
-    "train-framework",
-    "eval",
-)
-
-LANE_SCRIPT_TO_KEY = {
-    "api_server.sh": "api-server",
-    "distillation_dmd.sh": "distillation",
-    "eval.sh": "eval",
-    "golden_gate.sh": "golden-gate",
-    "inference_lora.sh": "lora-inference",
-    "inference_vmoba.sh": "inference-vmoba",
-    "lora_extraction.sh": "lora-extraction",
-    "performance.sh": "performance",
-    "self_forcing.sh": "self-forcing",
-    "ssim.sh": "ssim",
-    "train_framework.sh": "train-framework",
-    "training.sh": "training",
-    "training_lora.sh": "lora-training",
-    "training_vsa.sh": "training-vsa",
-}
-
-FASTCHECK_LANE_SCRIPTS = {
-    "dreamverse.sh",
-    "encoder.sh",
-    "kernel_tests.sh",
-    "transformer.sh",
-    "vae.sh",
-}
-
-LEGACY_TRAINING_LANES = (
-    "training",
-    "distillation",
-    "self-forcing",
-    "lora-training",
-    "training-vsa",
-)
-
-ALL_TRAINING_LANES = (*LEGACY_TRAINING_LANES, "train-framework")
-
-SSIM_SMOKE_TESTS = (
-    "test_flux_t2i_similarity.py",
-    "test_wan_t2v_similarity.py",
-)
-
-SAFE_PATTERNS = (
-    "*.md",
-    "*.rst",
-    ".agents/**",
-    ".claude/**",
-    ".codex/**",
-    ".github/ISSUE_TEMPLATE/**",
-    ".github/PULL_REQUEST_TEMPLATE.md",
-    ".github/dependabot.yml",
-    ".github/mergify.yml",
-    ".github/scripts/**",
-    ".github/workflows/**",
-    ".buildkite/scripts/pre_commit.sh",
-    ".git-blame-ignore-revs",
-    ".gitattributes",
-    ".gitignore",
-    ".pre-commit-config.yaml",
-    "AGENTS.md",
-    "CITATION.cff",
-    "CODE_OF_CONDUCT.md",
-    "CONTRIBUTING.md",
-    "LICENSE",
-    "NOTICE",
-    "__init__.py",
-    "collect_env.py",
-    "SECURITY.md",
-    "assets/**",
-    "comfyui/**",
-    "docs/**",
-    "examples/**",
-    "mkdocs.yml",
-    "requirements-mkdocs.in",
-    "requirements-mkdocs.txt",
-    "scripts/**",
-    "tests/__init__.py",
-    "tests/local_tests/**",
-)
-
-ALL_IMPACT_PATTERNS = (
-    ".buildkite/pipeline.yml",
-    "docker/**",
-    "pyproject.toml",
-    "requirements*.txt",
-    "setup.cfg",
-    "setup.py",
-    "uv.lock",
-)
-
-
-@dataclass(frozen=True)
-class FamilyCoverage:
-    pattern: re.Pattern[str]
-    golden_tests: tuple[str, ...]
-    ssim_tests: tuple[str, ...]
-
-
-FAMILY_COVERAGE = (
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])dreamx(_world)?([/_.-]|$)"),
-        ("test_dreamx.py", ),
-        ("test_dreamx_world_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])flux[_-]?2([/_.-]|$)"),
-        ("test_flux2_klein.py", ),
-        ("test_flux2_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])flux(?![_-]?2)([/_.-]|$)"),
-        ("test_flux.py", ),
-        ("test_flux_t2i_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])(hunyuan)?gamecraft([/_.-]|$)"),
-        ("test_gamecraft.py", ),
-        ("test_gamecraft_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])gen3c([/_.-]|$)"),
-        ("test_gen3c.py", ),
-        ("test_gen3c_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])glm[_-]?image([/_.-]|$)"),
-        ("test_glm_image.py", ),
-        ("test_glm_image_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])kandinsky[_-]?5([/_.-]|$)"),
-        ("test_kandinsky5.py", ),
-        ("test_kandinsky5_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])lingbot([a-z0-9_-]*)([/_.-]|$)"),
-        ("test_lingbot.py", ),
-        ("test_lingbot_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])longcat([/_.-]|$)"),
-        ("test_longcat.py", ),
-        ("test_longcat_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])ltx[_-]?2([/_.-]|$)"),
-        ("test_ltx2.py", ),
-        ("test_ltx2_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])matrixgame[_-]?2([/_.-]|$)"),
-        ("test_matrixgame.py", ),
-        ("test_matrixgame2_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])matrixgame[_-]?3([/_.-]|$)"),
-        ("test_matrixgame.py", ),
-        ("test_matrixgame3_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])minimax[_-]?h3([/_.-]|$)"),
-        ("test_minimax_h3_t2v.py", ),
-        ("test_minimax_h3_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])sd[_-]?3([._-]?5)?([/_.-]|$)"),
-        ("test_sd35.py", ),
-        ("test_sd35_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])stable[_-]?audio([/_.-]|$)"),
-        ("test_stable_audio.py", ),
-        ("test_stable_audio_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])turbo(diffusion)?([/_.-]|$)"),
-        (),
-        ("test_turbodiffusion_similarity.py", ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])wan(video)?([/_.-]|$)"),
-        ("test_wan_t2v.py", ),
-        (
-            "test_causal_similarity.py",
-            "test_wan_i2v_similarity.py",
-            "test_wan_t2v_similarity.py",
-        ),
-    ),
-    FamilyCoverage(
-        re.compile(r"(^|[/_.-])z[_-]?image([/_.-]|$)"),
-        ("test_zimage.py", ),
-        ("test_zimage_similarity.py", ),
-    ),
-)
-
-
-@dataclass
-class MergePlan:
-    lanes: set[str] = field(default_factory=set)
-    golden_tests: set[str] = field(default_factory=set)
-    ssim_tests: set[str] = field(default_factory=set)
-    golden_all: bool = False
-    ssim_all: bool = False
-    reasons: list[str] = field(default_factory=list)
-
-    def add_lanes(self, *lanes: str, reason: str) -> None:
-        unknown = set(lanes) - set(MERGE_LANES)
-        if unknown:
-            raise ValueError(f"Unknown merge lanes: {sorted(unknown)}")
-        self.lanes.update(lanes)
-        self.reasons.append(reason)
-
-    def add_golden(self, tests: tuple[str, ...], reason: str) -> None:
-        self.add_lanes("golden-gate", reason=reason)
-        self.golden_tests.update(tests)
-
-    def add_ssim(self, tests: tuple[str, ...], reason: str) -> None:
-        self.add_lanes("ssim", reason=reason)
-        self.ssim_tests.update(tests)
-
-    def require_all(self, reason: str) -> None:
-        self.lanes.update(MERGE_LANES)
-        self.golden_all = True
-        self.ssim_all = True
-        self.reasons.append(reason)
-
-    def ordered_lanes(self) -> tuple[str, ...]:
-        return tuple(lane for lane in MERGE_LANES if lane in self.lanes)
-
-    def encoded_lanes(self) -> str:
-        lanes = self.ordered_lanes()
-        return "," + ",".join(lanes or ("none", )) + ","
-
-    def encoded_golden_tests(self) -> str:
-        if "golden-gate" not in self.lanes:
-            return "none"
-        if self.golden_all or not self.golden_tests:
-            return "all"
-        return ",".join(sorted(self.golden_tests))
-
-    def encoded_ssim_tests(self) -> str:
-        if "ssim" not in self.lanes:
-            return "none"
-        if self.ssim_all or not self.ssim_tests:
-            return "all"
-        return ",".join(sorted(self.ssim_tests))
-
-
-def _matches_any(path: str, patterns: tuple[str, ...]) -> bool:
-    return any(fnmatch.fnmatchcase(path, pattern) for pattern in patterns)
-
-
-def _family_coverage(path: str) -> tuple[set[str], set[str]]:
-    normalized = path.lower()
-    golden: set[str] = set()
-    ssim: set[str] = set()
-    for family in FAMILY_COVERAGE:
-        if family.pattern.search(normalized):
-            golden.update(family.golden_tests)
-            ssim.update(family.ssim_tests)
-    return golden, ssim
-
-
-def _select_output_coverage(plan: MergePlan, path: str) -> None:
-    golden, ssim = _family_coverage(path)
-    if golden:
-        plan.add_golden(tuple(sorted(golden)), reason=f"model-family golden coverage: {path}")
-    else:
-        plan.golden_all = True
-        plan.add_lanes("golden-gate", reason=f"shared output golden coverage: {path}")
-    if ssim:
-        plan.add_ssim(tuple(sorted(ssim)), reason=f"model-family SSIM coverage: {path}")
-    else:
-        plan.add_ssim(SSIM_SMOKE_TESTS, reason=f"shared output SSIM smoke coverage: {path}")
-
-
-def classify_paths(paths: list[str]) -> MergePlan:
-    plan = MergePlan()
-    normalized_paths: list[str] = []
-    for raw_path in paths:
-        path = raw_path.strip()
-        while path.startswith("./"):
-            path = path[2:]
-        if path:
-            normalized_paths.append(path)
-    normalized_paths = sorted(set(normalized_paths))
-    if not normalized_paths:
-        plan.require_all("changed-file list was empty; failing closed")
-        return plan
-
-    for path in normalized_paths:
-        if path == "__FASTVIDEO_CI_PLAN_ALL__":
-            plan.require_all("changed-file API failed; failing closed")
-            continue
-
-        if path in {"requirements-mkdocs.in", "requirements-mkdocs.txt"}:
-            plan.reasons.append(f"documentation dependencies need no GPU integration: {path}")
-            continue
-
-        if _matches_any(path, ALL_IMPACT_PATTERNS):
-            plan.require_all(f"cross-cutting build/runtime surface: {path}")
-            continue
-
-        lane_script_prefix = ".buildkite/scripts/lanes/"
-        if path.startswith(lane_script_prefix):
-            script_name = Path(path).name
-            lane = LANE_SCRIPT_TO_KEY.get(script_name)
-            if lane is None:
-                if script_name in FASTCHECK_LANE_SCRIPTS:
-                    plan.reasons.append(f"covered by automatic Fastcheck lane: {path}")
-                else:
-                    plan.require_all(f"unknown lane script: {path}")
-            elif lane == "golden-gate":
-                plan.golden_all = True
-                plan.add_lanes(lane, reason=f"golden lane implementation: {path}")
-            elif lane == "ssim":
-                plan.ssim_all = True
-                plan.add_lanes(lane, reason=f"SSIM lane implementation: {path}")
-            else:
-                plan.add_lanes(lane, reason=f"lane implementation: {path}")
-            continue
-
-        if path.startswith("fastvideo/tests/golden_gate/"):
-            name = Path(path).name
-            if name.startswith("test_") and name.endswith(".py"):
-                plan.add_golden((name, ), reason=f"changed golden test: {path}")
-            elif name in {"AGENTS.md", "README.md"}:
-                plan.reasons.append(f"golden documentation only: {path}")
-            else:
-                plan.golden_all = True
-                plan.add_lanes("golden-gate", reason=f"shared golden harness/reference: {path}")
-            continue
-
-        if path.startswith("fastvideo/tests/ssim/"):
-            name = Path(path).name
-            if name.startswith("test_") and name.endswith(".py"):
-                plan.add_ssim((name, ), reason=f"changed SSIM test: {path}")
-            elif path.endswith((".py", ".json", ".pt", ".png", ".mp4")):
-                plan.ssim_all = True
-                plan.add_lanes("ssim", reason=f"shared SSIM harness/reference: {path}")
-            continue
-
-        if path.startswith("fastvideo/tests/performance/") or path.startswith(".buildkite/performance-benchmarks/"):
-            plan.add_lanes("performance", reason=f"performance coverage: {path}")
-            continue
-        if path.startswith(("fastvideo/performance/", "fastvideo/performance_dashboard/",
-                            "apps/performance_dashboard/")):
-            plan.add_lanes("performance", reason=f"performance implementation: {path}")
-            continue
-        if path.startswith("fastvideo/benchmarks/"):
-            if "/mlx_" in path or Path(path).name.startswith("mlx_"):
-                plan.reasons.append(f"covered by the path-filtered macOS MLX workflow: {path}")
-            else:
-                plan.add_lanes("performance", reason=f"benchmark implementation: {path}")
-            continue
-        if path.startswith("fastvideo/tests/eval/") or path.startswith("fastvideo/eval/"):
-            plan.add_lanes("eval", reason=f"evaluation coverage: {path}")
-            continue
-        if path.startswith("fastvideo/third_party/eval/"):
-            plan.add_lanes("eval", reason=f"vendored evaluation implementation: {path}")
-            continue
-        if path.startswith("fastvideo/tests/lora_extraction/") or path.startswith("scripts/lora_extraction/"):
-            plan.add_lanes("lora-extraction", reason=f"LoRA extraction coverage: {path}")
-            continue
-        if path.startswith("fastvideo/tests/inference/lora/"):
-            plan.add_lanes("lora-inference", reason=f"LoRA inference coverage: {path}")
-            continue
-        if path.startswith("fastvideo/tests/inference/vmoba/"):
-            plan.add_lanes("inference-vmoba", reason=f"VMoBA inference coverage: {path}")
-            continue
-        if path.startswith(("fastvideo/dataset/", "fastvideo/workflow/", "fastvideo/pipelines/preprocess/",
-                            "fastvideo/pipelines/training/")):
-            plan.add_lanes(*ALL_TRAINING_LANES, reason=f"shared data/training input surface: {path}")
-            continue
-        if path.startswith("fastvideo/tests/train/") or path.startswith("fastvideo/train/"):
-            plan.add_lanes("train-framework", reason=f"modular training coverage: {path}")
-            continue
-
-        if path.startswith("fastvideo/tests/training/"):
-            lowered = path.lower()
-            if "/vanilla/" in lowered:
-                plan.add_lanes("training", reason=f"vanilla training coverage: {path}")
-            elif "/distill/" in lowered:
-                plan.add_lanes("distillation", reason=f"distillation coverage: {path}")
-            elif "/self-forcing/" in lowered:
-                plan.add_lanes("self-forcing", reason=f"self-forcing coverage: {path}")
-            elif "/lora/" in lowered:
-                plan.add_lanes("lora-training", reason=f"LoRA training coverage: {path}")
-            elif "/vsa/" in lowered:
-                plan.add_lanes("training-vsa", reason=f"VSA training coverage: {path}")
-            else:
-                plan.add_lanes(*LEGACY_TRAINING_LANES, reason=f"shared legacy training coverage: {path}")
-            continue
-
-        if path.startswith("fastvideo/training/"):
-            lowered = path.lower()
-            if "self_forcing" in lowered:
-                plan.add_lanes("self-forcing", reason=f"self-forcing implementation: {path}")
-            elif "distill" in lowered:
-                plan.add_lanes("distillation", reason=f"distillation implementation: {path}")
-            elif "lora" in lowered:
-                plan.add_lanes("lora-training", reason=f"LoRA training implementation: {path}")
-            else:
-                plan.add_lanes(*LEGACY_TRAINING_LANES, reason=f"shared legacy training implementation: {path}")
-            continue
-
-        lowered = path.lower()
-        if "vmoba" in lowered and path.startswith(("fastvideo/", ".buildkite/")):
-            plan.add_lanes("inference-vmoba", reason=f"VMoBA implementation: {path}")
-            plan.add_golden(("test_wan_t2v.py", ), reason=f"VMoBA end-to-end coverage: {path}")
-            continue
-        if "lora" in lowered and path.startswith("fastvideo/"):
-            plan.add_lanes(
-                "lora-inference",
-                "lora-extraction",
-                "lora-training",
-                reason=f"shared LoRA implementation: {path}",
-            )
-            _select_output_coverage(plan, path)
-            continue
-
-        if path.startswith("fastvideo/entrypoints/") or path.startswith("fastvideo/api/"):
-            plan.add_lanes("api-server", reason=f"API/entrypoint integration: {path}")
-            if "openai" not in lowered and "/cli/" not in lowered:
-                _select_output_coverage(plan, path)
-            continue
-        if path.startswith("fastvideo/worker/"):
-            plan.add_lanes("api-server", reason=f"worker/API integration: {path}")
-            _select_output_coverage(plan, path)
-            continue
-        if path.startswith("fastvideo/distributed/"):
-            plan.add_lanes(
-                "training",
-                "train-framework",
-                reason=f"distributed runtime integration: {path}",
-            )
-            _select_output_coverage(plan, path)
-            continue
-        if path.startswith(("fastvideo/hooks/", "fastvideo/platforms/", "fastvideo/third_party/")):
-            _select_output_coverage(plan, path)
-            continue
-        if path.startswith(("fastvideo/models/", "fastvideo/pipelines/", "fastvideo/configs/",
-                            "fastvideo/layers/", "fastvideo/attention/")):
-            _select_output_coverage(plan, path)
-            continue
-        if path in {
-                "fastvideo/fastvideo_args.py",
-                "fastvideo/forward_context.py",
-                "fastvideo/image_processor.py",
-                "fastvideo/registry.py",
-                "fastvideo/utils.py",
-        }:
-            _select_output_coverage(plan, path)
-            continue
-        if path.startswith("fastvideo/mlx_runtime/"):
-            plan.reasons.append(f"covered by the path-filtered macOS MLX workflow: {path}")
-            continue
-        if path.startswith("fastvideo/logging_utils/") or path in {
-                "fastvideo/__init__.py",
-                "fastvideo/envs.py",
-                "fastvideo/logger.py",
-                "fastvideo/profiler.py",
-                "fastvideo/version.py",
-        }:
-            plan.reasons.append(f"covered by automatic Fastcheck: {path}")
-            continue
-        if path.startswith(("fastvideo-kernel/", "csrc/")):
-            plan.add_golden(("test_wan_t2v.py", ), reason=f"kernel integration smoke: {path}")
-            plan.add_ssim(("test_wan_t2v_similarity.py", ), reason=f"kernel numerical smoke: {path}")
-            continue
-
-        if path.startswith("apps/dreamverse/"):
-            # DreamVerse is already one of the six automatic Fastcheck lanes.
-            plan.reasons.append(f"covered by automatic DreamVerse Fastcheck: {path}")
-            continue
-        if path.startswith("fastvideo/tests/"):
-            # The automatic unit/component Fastcheck lanes own the remaining
-            # package tests. Domain-specific expensive test roots were handled
-            # above.
-            plan.reasons.append(f"covered by automatic Fastcheck: {path}")
-            continue
-        if path in {".buildkite/scripts/unit_test.sh", ".buildkite/scripts/pr_test.sh"}:
-            plan.reasons.append(f"covered by automatic unit Fastcheck: {path}")
-            continue
-        if _matches_any(path, SAFE_PATTERNS):
-            plan.reasons.append(f"no additional GPU integration needed: {path}")
-            continue
-
-        plan.require_all(f"unclassified path; failing closed: {path}")
-
-    return plan
-
-
-def _write_github_output(output: TextIO, plan: MergePlan) -> None:
-    output.write(f"merge_test_plan={plan.encoded_lanes()}\n")
-    output.write(f"merge_golden_tests={plan.encoded_golden_tests()}\n")
-    output.write(f"merge_ssim_tests={plan.encoded_ssim_tests()}\n")
-    output.write(f"merge_plan_label={','.join(plan.ordered_lanes()) or 'none'}\n")
-
-
-def _write_summary(output: TextIO, plan: MergePlan) -> None:
-    output.write("## Change-aware merge test plan\n\n")
-    output.write("| Selection | Value |\n|---|---|\n")
-    output.write(f"| Additional Slurm lanes | `{','.join(plan.ordered_lanes()) or 'none'}` |\n")
-    output.write(f"| Golden tests | `{plan.encoded_golden_tests()}` |\n")
-    output.write(f"| SSIM tests | `{plan.encoded_ssim_tests()}` |\n\n")
-    output.write("Fastcheck remains the universal six-lane baseline.\n")
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--paths-file", type=Path, required=True)
-    parser.add_argument("--github-output", type=Path)
-    parser.add_argument("--summary-file", type=Path)
-    return parser.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-    paths = args.paths_file.read_text(encoding="utf-8").splitlines()
-    plan = classify_paths(paths)
-    print(f"MERGE_TEST_PLAN={plan.encoded_lanes()}")
-    print(f"MERGE_GOLDEN_TESTS={plan.encoded_golden_tests()}")
-    print(f"MERGE_SSIM_TESTS={plan.encoded_ssim_tests()}")
-    for reason in plan.reasons:
-        print(f"- {reason}")
-    if args.github_output:
-        with args.github_output.open("a", encoding="utf-8") as output:
-            _write_github_output(output, plan)
-    if args.summary_file:
-        with args.summary_file.open("a", encoding="utf-8") as output:
-            _write_summary(output, plan)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

.github/scripts/test_gate_full_suite.sh

@@ -53,7 +53,7 @@ PC_PENDING='{"name": "pre-commit", "id": 1, "status": "in_progress", "conclusion
 DOCS_OK='{"name": "Deploy Documentation", "id": 2, "status": "completed", "conclusion": "success"}'
 DOCS_BAD='{"name": "Deploy Documentation", "id": 2, "status": "completed", "conclusion": "failure"}'
 DOCS_CANCELLED='{"name": "Deploy Documentation", "id": 2, "status": "completed", "conclusion": "cancelled"}'
-OTHER='{"name": "Trigger Merge Gate", "id": 3, "status": "in_progress", "conclusion": null}'
+OTHER='{"name": "Trigger Full Suite", "id": 3, "status": "in_progress", "conclusion": null}'
 NULL_NAME='{"name": null, "id": 4, "status": "completed", "conclusion": "failure"}'
 PC_OK_RERUN='{"name": "pre-commit", "id": 5, "status": "completed", "conclusion": "success"}'
 

.github/workflows/_template-build-image.yml

@@ -190,7 +190,6 @@ jobs:
         if: ${{ !inputs.push_by_digest }}
         run: |
           echo "✅ Python ${{ inputs.python_version }} image successfully built and pushed to ${{ steps.image.outputs.name }}:${{ inputs.tag_suffix }}-sha-${GITHUB_SHA::7}"
-          echo "Digest: ${{ steps.build-push.outputs.digest }}"
           echo "To run tests with this image, manually trigger the 'Run Tests' workflow."
 
       - name: Digest success message

.github/workflows/ci-aggregate-status.yml

@@ -26,48 +26,29 @@ jobs:
               per_page: 100,
             });
 
-            // Buildkite derives the GitHub context prefix from the label emoji.
-            // Keep hard Full Suite lanes in test-tube/bar-chart namespaces and
-            // Fastcheck lanes in microscope so targeted reruns cannot clear the
-            // wrong aggregate status. Automatic PR jobs use pr-fastcheck while
-            // slash-command and Full Suite jobs use ci; normalize the suffix
-            // and keep the newest status for each logical lane.
-            const FASTCHECK_PREFIXES = [
-              'buildkite/pr-fastcheck/microscope-',
-              'buildkite/ci/microscope-',
-            ];
+            const bkStatuses = data.statuses.filter(
+              s => s.context.startsWith('buildkite/ci/')
+            );
+
+            const FASTCHECK_PREFIX = 'buildkite/ci/microscope-';
             const FULL_SUITE_PREFIXES = [
               'buildkite/ci/test-tube-',
               'buildkite/ci/bar-chart-',
             ];
 
-            function newestByLane(prefixes) {
-              const statuses = new Map();
-              for (const status of data.statuses) {
-                const prefix = prefixes.find(p => status.context.startsWith(p));
-                if (!prefix) continue;
-                const lane = status.context.slice(prefix.length);
-                const previous = statuses.get(lane);
-                if (!previous || Date.parse(status.updated_at) > Date.parse(previous.updated_at)) {
-                  statuses.set(lane, status);
-                }
-              }
-              return statuses;
-            }
+            const fastcheck = bkStatuses.filter(
+              s => s.context.startsWith(FASTCHECK_PREFIX)
+            );
+            const fullSuite = bkStatuses.filter(
+              s => FULL_SUITE_PREFIXES.some(p => s.context.startsWith(p))
+            );
 
-            const fastcheck = newestByLane(FASTCHECK_PREFIXES);
-            const fullSuiteOnly = newestByLane(FULL_SUITE_PREFIXES);
-            const fastcheckPassed =
-              fastcheck.size === 6
-              && [...fastcheck.values()].every(s => s.state === 'success');
-            const fullSuitePassed =
-              fastcheckPassed
-              && fullSuiteOnly.size === 14
-              && [...fullSuiteOnly.values()].every(s => s.state === 'success');
-
-            if (fastcheckPassed) {
+            if (
+              fastcheck.length > 0
+              && fastcheck.every(s => s.state === 'success')
+            ) {
               core.info(
-                `All ${fastcheck.size} fastcheck tests passed — updating fastcheck-passed`
+                `All ${fastcheck.length} fastcheck tests passed — updating fastcheck-passed`
               );
               await github.rest.repos.createCommitStatus({
                 owner: context.repo.owner,
@@ -75,13 +56,17 @@ jobs:
                 sha,
                 state: 'success',
                 context: 'fastcheck-passed',
-                description: `All ${fastcheck.size} fastcheck tests passed`,
+                description:
+                  `All ${fastcheck.length} fastcheck tests passed`,
               });
             }
 
-            if (fullSuitePassed) {
+            if (
+              fullSuite.length > 0
+              && fullSuite.every(s => s.state === 'success')
+            ) {
               core.info(
-                'All 20 full suite tests passed — updating full-suite-passed'
+                `All ${fullSuite.length} full suite tests passed — updating full-suite-passed`
               );
               await github.rest.repos.createCommitStatus({
                 owner: context.repo.owner,
@@ -89,6 +74,7 @@ jobs:
                 sha,
                 state: 'success',
                 context: 'full-suite-passed',
-                description: 'All 20 full suite tests passed',
+                description:
+                  `All ${fullSuite.length} full suite tests passed`,
               });
             }

.github/workflows/ci-macos-mlx.yml

@@ -1,151 +0,0 @@
-name: macOS MLX Smoke
-
-on:
-  pull_request:
-    branches: [main]
-    paths:
-      - ".github/workflows/ci-macos-mlx.yml"
-      - "fastvideo/mlx_runtime/**"
-      - "fastvideo/tests/mlx/**"
-      - "fastvideo/tests/platforms/test_mps_vsa_error.py"
-      - "fastvideo/platforms/mps.py"
-      - "fastvideo/platforms/__init__.py"
-      - "fastvideo/__init__.py"
-      - "examples/inference/basic/mlx_*.py"
-      - "fastvideo/benchmarks/mlx_*.py"
-      - "pyproject.toml"
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: macos-mlx-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  mlx-smoke:
-    if: github.event_name == 'workflow_dispatch' || github.event.pull_request.draft != true
-    runs-on: macos-15
-    timeout-minutes: 25
-    env:
-      FASTVIDEO_ATTENTION_BACKEND: TORCH_SDPA
-      TOKENIZERS_PARALLELISM: "false"
-      MASTER_ADDR: localhost
-      MASTER_PORT: "29513"
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-          cache: pip
-
-      - uses: astral-sh/setup-uv@v3
-
-      - name: Install lightweight MLX smoke dependencies
-        run: |
-          uv pip install --system \
-            --index-url https://download.pytorch.org/whl/cpu \
-            torch==2.11.0 torchvision torchaudio
-          uv pip install --system \
-            pytest numpy scipy pillow imageio einops cloudpickle filelock \
-            PyYAML diffusers huggingface_hub remote-pdb safetensors loguru mlx \
-            "ftfy>=6.3.1" "opencv-python>=4.10.0.84" psutil "transformers>=5.0.0"
-
-      - name: Show Apple runtime
-        run: |
-          python - <<'PY'
-          import platform
-          import mlx.core as mx
-          import torch
-
-          print("machine:", platform.machine())
-          print("processor:", platform.processor())
-          print("mlx default device:", mx.default_device())
-          memory_size = mx.metal.device_info().get("memory_size") if mx.metal.is_available() else "metal unavailable"
-          print("mlx memory_size:", memory_size)
-          print("torch:", torch.__version__)
-          print("torch mps available:", torch.backends.mps.is_available())
-          PY
-
-      - name: Run MLX smoke tests
-        run: |
-          python -m pytest \
-            fastvideo/tests/mlx/test_dmd_sampling.py \
-            fastvideo/tests/mlx/test_memory_limits.py \
-            fastvideo/tests/mlx/test_quant_capability.py \
-            fastvideo/tests/mlx/test_mlx_dit_parity.py \
-            fastvideo/tests/mlx/test_mlx_compile_parity.py \
-            fastvideo/tests/mlx/test_mlx_checkpoint.py \
-            fastvideo/tests/mlx/test_mlx_checkpoint_compat.py \
-            fastvideo/tests/mlx/test_mlx_fastwan_benchmark.py \
-            fastvideo/tests/mlx/test_taehv_decode.py \
-            fastvideo/tests/mlx/test_frame_upsample.py \
-            fastvideo/tests/mlx/test_mlx_fast_spatial.py \
-            fastvideo/tests/mlx/test_mlx_refine.py \
-            fastvideo/tests/mlx/test_mlx_prompt_to_video_decode.py \
-            fastvideo/tests/mlx/test_mlx_wan22_prompt_cache_fingerprint.py \
-            fastvideo/tests/mlx/test_wan22_sample.py \
-            fastvideo/tests/mlx/test_windowed_attention.py \
-            fastvideo/tests/mlx/test_mlx_rife_interpolation.py::test_rife_download_unavailable_has_specific_error \
-            fastvideo/tests/mlx/test_mlx_rife_interpolation.py::test_rife_backend_regression_is_not_skip_eligible \
-            fastvideo/tests/platforms/test_mps_vsa_error.py \
-            -q
-
-  # Same tests on MLX's CPU backend. Hosted macOS runners are scarce and
-  # slower to schedule; this Linux job gives fast PR signal on the identical
-  # graph (the parity tests were designed to be backend-agnostic), while the
-  # macOS job above stays the source of truth for Metal behavior.
-  mlx-smoke-linux-cpu:
-    if: github.event_name == 'workflow_dispatch' || github.event.pull_request.draft != true
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    env:
-      FASTVIDEO_ATTENTION_BACKEND: TORCH_SDPA
-      TOKENIZERS_PARALLELISM: "false"
-      MASTER_ADDR: localhost
-      MASTER_PORT: "29513"
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-          cache: pip
-
-      - uses: astral-sh/setup-uv@v3
-
-      - name: Install lightweight MLX smoke dependencies (CPU backend)
-        run: |
-          uv pip install --system \
-            --index-url https://download.pytorch.org/whl/cpu \
-            torch==2.11.0 torchvision torchaudio
-          uv pip install --system \
-            pytest numpy scipy pillow imageio einops cloudpickle filelock \
-            PyYAML diffusers huggingface_hub remote-pdb safetensors loguru "mlx[cpu]" \
-            "ftfy>=6.3.1" "opencv-python>=4.10.0.84" psutil "transformers>=5.0.0"
-
-      - name: Run MLX smoke tests (CPU backend)
-        run: |
-          python -m pytest \
-            fastvideo/tests/mlx/test_dmd_sampling.py \
-            fastvideo/tests/mlx/test_memory_limits.py \
-            fastvideo/tests/mlx/test_quant_capability.py \
-            fastvideo/tests/mlx/test_mlx_dit_parity.py \
-            fastvideo/tests/mlx/test_mlx_compile_parity.py \
-            fastvideo/tests/mlx/test_mlx_checkpoint.py \
-            fastvideo/tests/mlx/test_mlx_checkpoint_compat.py \
-            fastvideo/tests/mlx/test_mlx_fastwan_benchmark.py \
-            fastvideo/tests/mlx/test_taehv_decode.py \
-            fastvideo/tests/mlx/test_frame_upsample.py \
-            fastvideo/tests/mlx/test_mlx_fast_spatial.py \
-            fastvideo/tests/mlx/test_mlx_refine.py \
-            fastvideo/tests/mlx/test_mlx_prompt_to_video_decode.py \
-            fastvideo/tests/mlx/test_mlx_wan22_prompt_cache_fingerprint.py \
-            fastvideo/tests/mlx/test_wan22_sample.py \
-            fastvideo/tests/mlx/test_windowed_attention.py \
-            fastvideo/tests/mlx/test_mlx_rife_interpolation.py::test_rife_download_unavailable_has_specific_error \
-            fastvideo/tests/mlx/test_mlx_rife_interpolation.py::test_rife_backend_regression_is_not_skip_eligible \
-            fastvideo/tests/platforms/test_mps_vsa_error.py \
-            -q

.github/workflows/ci-scheduled-ssim.yml

@@ -1,44 +0,0 @@
-name: Scheduled Full SSIM
-
-on:
-  schedule:
-    - cron: "0 5 * * 0"
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  trigger:
-    if: github.repository == 'hao-ai-lab/FastVideo'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Trigger weekly full SSIM on Slinky Slurm
-        env:
-          BUILDKITE_API_TOKEN: ${{ secrets.BUILDKITE_API_TOKEN }}
-          SOURCE_SHA: ${{ github.sha }}
-          SOURCE_BRANCH: ${{ github.event.repository.default_branch }}
-          BK_ORG: ${{ vars.BUILDKITE_ORG_SLUG }}
-          BK_PIPELINE: ${{ vars.BUILDKITE_PIPELINE_SLUG }}
-        run: |
-          set -euo pipefail
-          curl -sS --fail-with-body -X POST \
-            "https://api.buildkite.com/v2/organizations/${BK_ORG}/pipelines/${BK_PIPELINE}/builds" \
-            -H "Authorization: Bearer $BUILDKITE_API_TOKEN" \
-            -H "Content-Type: application/json" \
-            --data-raw "$(jq -n \
-              --arg commit "$SOURCE_SHA" \
-              --arg branch "$SOURCE_BRANCH" \
-              '{
-                commit: $commit,
-                branch: $branch,
-                message: "Weekly full SSIM on Slinky Slurm",
-                ignore_pipeline_branch_filters: true,
-                env: {
-                  TEST_SCOPE: "scheduled",
-                  FULL_SUITE: "false",
-                  TEST_TYPE: "ssim",
-                  PR_NUMBER: "false",
-                  PR_TITLE: "Scheduled full SSIM"
-                }
-              }')"

.github/workflows/ci-slash-commands.yml

@@ -33,6 +33,7 @@ jobs:
             core.setOutput('has_write', String(hasWrite));
 
       - name: Add ready label and react
+        id: label
         if: steps.perm.outputs.has_write == 'true'
         uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
         with:
@@ -47,6 +48,47 @@ jobs:
               comment_id: context.payload.comment.id,
               content: 'rocket',
             });
+            const { data: pr } = await github.rest.pulls.get({ owner, repo, pull_number: prNumber });
+            core.setOutput('pr_sha', pr.head.sha);
+            core.setOutput('pr_branch', pr.head.ref);
+            core.setOutput('pr_number', String(prNumber));
+            core.setOutput('pr_title', pr.title);
+
+      - name: Trigger Full Suite
+        if: steps.perm.outputs.has_write == 'true'
+        env:
+          BUILDKITE_API_TOKEN: ${{ secrets.BUILDKITE_API_TOKEN }}
+          PR_SHA: ${{ steps.label.outputs.pr_sha }}
+          PR_BRANCH: ${{ steps.label.outputs.pr_branch }}
+          PR_NUMBER: ${{ steps.label.outputs.pr_number }}
+          PR_TITLE: ${{ steps.label.outputs.pr_title }}
+          BK_ORG: ${{ vars.BUILDKITE_ORG_SLUG }}
+          BK_PIPELINE: ${{ vars.BUILDKITE_PIPELINE_SLUG }}
+        run: |
+          curl -sS --fail-with-body -X POST \
+            "https://api.buildkite.com/v2/organizations/${BK_ORG}/pipelines/${BK_PIPELINE}/builds" \
+            -H "Authorization: Bearer $BUILDKITE_API_TOKEN" \
+            -H "Content-Type: application/json" \
+            --data-raw "$(jq -n \
+              --arg commit "$PR_SHA" \
+              --arg branch "$PR_BRANCH" \
+              --arg message "Full Suite for PR #${PR_NUMBER} (via /merge)" \
+              --arg pr_title "$PR_TITLE" \
+              --argjson pr_id "$PR_NUMBER" \
+              '{
+                commit: $commit,
+                branch: $branch,
+                message: $message,
+                ignore_pipeline_branch_filters: true,
+                pull_request_id: $pr_id,
+                pull_request_base_branch: "main",
+                env: {
+                    TEST_SCOPE: "full",
+                    FULL_SUITE: "true",
+                    PR_NUMBER: ($pr_id | tostring),
+                    PR_TITLE: $pr_title
+                  }
+                }')"
 
   parse-command:
     if: >-
@@ -87,7 +129,7 @@ jobs:
           set -euo pipefail
           TEST_NAME=$(echo "$COMMENT" | grep -oP '(?<=/test\s)\S+' | head -1 || true)
 
-          VALID="encoder vae transformer kernel unit dreamverse ssim golden-gate training lora-inference lora-training lora-extraction distillation self-forcing vsa vmoba performance api train-framework eval unit-ci kernel-ci dreamverse-ci ssim-ci golden-gate-ci encoder-ci vae-ci transformer-ci lora-inference-ci lora-training-ci lora-extraction-ci training-ci distillation-ci self-forcing-ci vsa-ci vmoba-ci performance-ci api-ci train-framework-ci eval-ci full fastcheck pre-commit"
+          VALID="encoder vae transformer kernel unit dreamverse ssim golden-gate training lora-inference lora-training lora-extraction distillation self-forcing vsa vmoba performance api train-framework eval full fastcheck pre-commit"
           if [ -z "$TEST_NAME" ] || ! echo "$VALID" | grep -qw "$TEST_NAME"; then
             echo "Unknown test: '$TEST_NAME'. Valid: $VALID"
             exit 1
@@ -95,17 +137,7 @@ jobs:
 
           declare -A MAP=(
             [encoder]=encoder [vae]=vae [transformer]=transformer
-            [kernel]=kernel_tests [unit]=unit_test [unit-ci]=unit_test_ci
-            [kernel-ci]=kernel_tests_ci [dreamverse-ci]=dreamverse_app_ci
-            [ssim-ci]=ssim_ci [vmoba-ci]=inference_vmoba_ci
-            [golden-gate-ci]=golden_gate_ci [training-ci]=training_ci
-            [encoder-ci]=encoder_ci [vae-ci]=vae_ci [transformer-ci]=transformer_ci
-            [lora-inference-ci]=inference_lora_ci [lora-training-ci]=training_lora_ci
-            [lora-extraction-ci]=lora_extraction_ci [distillation-ci]=distillation_dmd_ci
-            [self-forcing-ci]=self_forcing_ci [vsa-ci]=training_vsa_ci
-            [performance-ci]=performance_ci [api-ci]=api_server_ci
-            [train-framework-ci]=train_framework_ci [eval-ci]=eval_ci
-            [dreamverse]=dreamverse_app
+            [kernel]=kernel_tests [unit]=unit_test [dreamverse]=dreamverse_app
             [ssim]=ssim [golden-gate]=golden_gate [training]=training
             [lora-inference]=inference_lora [lora-training]=training_lora
             [lora-extraction]=lora_extraction

.github/workflows/ci-trigger-full-suite.yml

@@ -1,4 +1,4 @@
-name: Trigger Merge Gate
+name: Trigger Full Suite
 
 on:
   pull_request_target:
@@ -10,7 +10,7 @@ permissions:
   actions: read
 
 concurrency:
-  group: merge-gate-${{ github.event.pull_request.number }}
+  group: full-suite-${{ github.event.pull_request.number }}
   cancel-in-progress: false
 
 jobs:
@@ -34,72 +34,29 @@ jobs:
             });
             const hasReady = pr.labels.some(l => l.name === 'ready');
             core.setOutput('has_ready', String(hasReady));
-            core.setOutput('changed_files', String(pr.changed_files));
-            if (!hasReady) core.info('No ready label — skipping merge-gate trigger.');
+            if (!hasReady) core.info('No ready label — skipping Full Suite trigger.');
 
       - name: Cancel previous Buildkite builds
         if: steps.check.outputs.has_ready == 'true'
         env:
           BUILDKITE_API_TOKEN: ${{ secrets.BUILDKITE_API_TOKEN }}
           PR_BRANCH: ${{ github.event.pull_request.head.ref }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
         run: |
-          # Match both branch and PR number: forks can reuse the same branch name.
-          builds=$(curl -sS --get -H "Authorization: Bearer $BUILDKITE_API_TOKEN" \
-            --data-urlencode "branch=$PR_BRANCH" \
-            --data-urlencode "state=running,scheduled" \
-            "https://api.buildkite.com/v2/organizations/${{ vars.BUILDKITE_ORG_SLUG }}/pipelines/${{ vars.BUILDKITE_PIPELINE_SLUG }}/builds" \
-            | jq -r --arg pr_number "$PR_NUMBER" \
-              '.[] | select((.env.TEST_SCOPE? == "merge") and (.env.PR_NUMBER? == $pr_number)) | .number')
+          # Find running builds for this branch with TEST_SCOPE=full and cancel them
+          builds=$(curl -sS -H "Authorization: Bearer $BUILDKITE_API_TOKEN" \
+            "https://api.buildkite.com/v2/organizations/${{ vars.BUILDKITE_ORG_SLUG }}/pipelines/${{ vars.BUILDKITE_PIPELINE_SLUG }}/builds?branch=${PR_BRANCH}&state=running,scheduled" \
+            | jq -r '.[] | select(try (.env.TEST_SCOPE == "full") catch false) | .number')
           for build_num in $builds; do
             echo "Cancelling Buildkite build #$build_num"
             curl -sS -X PUT -H "Authorization: Bearer $BUILDKITE_API_TOKEN" \
               "https://api.buildkite.com/v2/organizations/${{ vars.BUILDKITE_ORG_SLUG }}/pipelines/${{ vars.BUILDKITE_PIPELINE_SLUG }}/builds/${build_num}/cancel"
           done
 
-      # Check out the immutable BASE SHA: pull_request_target must never run a
-      # planner or gate script from the untrusted PR head.
-      - name: Checkout trusted merge planner
+      # Checks out the BASE branch (default for pull_request_target), so PR
+      # authors cannot tamper with the gate script.
+      - name: Checkout gate script
         if: steps.check.outputs.has_ready == 'true'
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          ref: ${{ github.event.pull_request.base.sha }}
-          persist-credentials: false
-
-      - name: Collect changed paths
-        if: steps.check.outputs.has_ready == 'true'
-        env:
-          GH_TOKEN: ${{ github.token }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          EXPECTED_CHANGED_FILES: ${{ steps.check.outputs.changed_files }}
-        run: |
-          set -euo pipefail
-          changed_json="$RUNNER_TEMP/merge-changed-files.json"
-          changed_paths="$RUNNER_TEMP/merge-changed-paths.txt"
-          if gh api --paginate --slurp \
-              "repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}/files?per_page=100" \
-              > "$changed_json"; then
-            observed=$(jq '[.[][] | .filename] | unique | length' "$changed_json")
-            if [ "$observed" = "$EXPECTED_CHANGED_FILES" ]; then
-              jq -r '.[][] | .filename, (.previous_filename // empty)' "$changed_json" \
-                | sort -u > "$changed_paths"
-            else
-              echo "::warning::Changed-file API returned $observed of $EXPECTED_CHANGED_FILES paths; selecting all merge lanes."
-              echo '__FASTVIDEO_CI_PLAN_ALL__' > "$changed_paths"
-            fi
-          else
-            echo "::warning::Changed-file API failed; selecting all merge lanes."
-            echo '__FASTVIDEO_CI_PLAN_ALL__' > "$changed_paths"
-          fi
-
-      - name: Select minimal merge tests
-        id: plan
-        if: steps.check.outputs.has_ready == 'true'
-        run: |
-          python3 .github/scripts/plan_merge_ci.py \
-            --paths-file "$RUNNER_TEMP/merge-changed-paths.txt" \
-            --github-output "$GITHUB_OUTPUT" \
-            --summary-file "$GITHUB_STEP_SUMMARY"
 
       - name: Wait for pre-commit and docs build
         if: steps.check.outputs.has_ready == 'true'
@@ -109,7 +66,7 @@ jobs:
           PR_NUMBER: ${{ github.event.pull_request.number }}
         run: bash .github/scripts/gate_full_suite.sh
 
-      - name: Trigger Buildkite merge gate
+      - name: Trigger Buildkite Full Suite
         if: steps.check.outputs.has_ready == 'true'
         env:
           BUILDKITE_API_TOKEN: ${{ secrets.BUILDKITE_API_TOKEN }}
@@ -119,10 +76,6 @@ jobs:
           PR_TITLE: ${{ github.event.pull_request.title }}
           BK_ORG: ${{ vars.BUILDKITE_ORG_SLUG }}
           BK_PIPELINE: ${{ vars.BUILDKITE_PIPELINE_SLUG }}
-          MERGE_TEST_PLAN: ${{ steps.plan.outputs.merge_test_plan }}
-          MERGE_GOLDEN_TESTS: ${{ steps.plan.outputs.merge_golden_tests }}
-          MERGE_SSIM_TESTS: ${{ steps.plan.outputs.merge_ssim_tests }}
-          MERGE_PLAN_LABEL: ${{ steps.plan.outputs.merge_plan_label }}
         run: |
           curl -sS --fail-with-body -X POST \
             "https://api.buildkite.com/v2/organizations/${BK_ORG}/pipelines/${BK_PIPELINE}/builds" \
@@ -131,11 +84,8 @@ jobs:
             --data-raw "$(jq -n \
               --arg commit "$PR_SHA" \
               --arg branch "$PR_BRANCH" \
-              --arg message "Merge gate [${MERGE_PLAN_LABEL}] for PR #${PR_NUMBER}" \
+              --arg message "Full Suite for PR #${PR_NUMBER}" \
               --arg pr_title "$PR_TITLE" \
-              --arg merge_test_plan "$MERGE_TEST_PLAN" \
-              --arg merge_golden_tests "$MERGE_GOLDEN_TESTS" \
-              --arg merge_ssim_tests "$MERGE_SSIM_TESTS" \
               --argjson pr_id "$PR_NUMBER" \
               '{
                 commit: $commit,
@@ -145,11 +95,8 @@ jobs:
                 pull_request_id: $pr_id,
                 pull_request_base_branch: "main",
                 env: {
-                  TEST_SCOPE: "merge",
+                  TEST_SCOPE: "full",
                   FULL_SUITE: "true",
-                  MERGE_TEST_PLAN: $merge_test_plan,
-                  MERGE_GOLDEN_TESTS: $merge_golden_tests,
-                  MERGE_SSIM_TESTS: $merge_ssim_tests,
                   PR_NUMBER: ($pr_id | tostring),
                   PR_TITLE: $pr_title
                 }

.github/workflows/community-welcome.yml

@@ -38,17 +38,17 @@ jobs:
 
             **How our CI works:**
 
-            PRs run a three-tier CI system:
+            PRs run a two-tier CI system:
             1. **Pre-commit** — formatting (yapf), linting (ruff), type checking (mypy). Runs immediately on every PR.
-            2. **Fastcheck** — six core GPU lanes run automatically via Buildkite (~10-15 min).
-            3. **Merge gate** — a reviewer adds `ready`; changed paths select only the relevant integration, training, golden, or SSIM coverage.
+            2. **Fastcheck** — core GPU tests (encoders, VAEs, transformers, kernels, unit tests). Runs automatically via Buildkite on relevant file changes (~10-15 min).
+            3. **Full Suite** — integration tests, training pipelines, SSIM regression. Runs only when a reviewer adds the `ready` label.
 
             **Before your PR is reviewed:**
             - [ ] `pre-commit run --all-files` passes locally
             - [ ] You've added or updated tests for your changes
             - [ ] The PR description explains what and why
 
-            If pre-commit fails, a bot comment will explain how to fix it. Fastcheck and merge-gate results appear in the Checks section below.
+            If pre-commit fails, a bot comment will explain how to fix it. Fastcheck and Full Suite results appear in the Checks section below.
 
             **Useful links:**
             - [Contributing Guide](https://hao-ai-lab.github.io/FastVideo/contributing/overview/)

.github/workflows/infra-build-image.yml

@@ -13,11 +13,6 @@ on:
         required: false
         default: false
         type: boolean
-      build_ci_runner_image:
-        description: 'Build the ARM64 CUDA 13 CI runner image (sm_100)'
-        required: false
-        default: false
-        type: boolean
   # Auto-rebuild the CUDA images when a repository-controlled image input
   # changes on main. This includes the trusted SM89 kernel artifact's source,
   # metadata/key helper, ABI dependency metadata, and build orchestration.
@@ -203,28 +198,6 @@ jobs:
           docker buildx imagetools create "${TAG_ARGS[@]}" "${IMAGE_REFS[@]}"
           docker buildx imagetools inspect "${TAGS[0]}"
 
-  # The CI runner is ARM64 like DGX Spark, but targets sm_100 rather than sm_121.
-  # Publish a single-architecture variant so the self-hosted CI runner can reuse
-  # the exact prebuilt kernel instead of compiling it in every job.
-  build-ci-runner-image:
-    if: ${{ (github.event_name == 'push' && github.repository == 'hao-ai-lab/FastVideo') || github.event.inputs.build_ci_runner_image == 'true' }}
-    uses: ./.github/workflows/_template-build-image.yml
-    with:
-      python_version: '3.12'
-      dockerfile_path: docker/Dockerfile
-      tag_suffix: py3.12-cuda13.0.0-sm100
-      runner: ubuntu-24.04-arm
-      architecture: arm64
-      build_args: |
-        PYTHON_VERSION=3.12
-        CUDA_VERSION=13.0.0
-        UV_TORCH_BACKEND=cu130
-        TORCH_CUDA_ARCH_LIST=10.0
-        CMAKE_BUILD_PARALLEL_LEVEL=1
-        FLASH_ATTN_WHEEL_TAG=cu130torch2.12
-        FLASH_ATTN_WHEEL_RELEASE_ARM64=https://github.com/mjun0812/flash-attention-prebuild-wheels/releases/download/v0.9.22
-    secrets: inherit
-
   # Dreamverse matrix: {backend, UI} x {12.6.3, 13.0.0}, Python 3.12. Torch backend
   # matches the base CUDA (cu126 / cu130). Keep these images amd64-only until the
   # required FA4 dependency stack is available and validated on arm64.

.github/workflows/infra-docs.yml

@@ -6,7 +6,6 @@ on:
     paths:
       - 'docs/**'
       - 'examples/**'
-      - 'scripts/inference/**'
       - 'mkdocs.yml'
       - 'requirements-mkdocs.in'
       - 'requirements-mkdocs.txt'
@@ -17,7 +16,6 @@ on:
     paths:
       - 'docs/**'
       - 'examples/**'
-      - 'scripts/inference/**'
       - 'mkdocs.yml'
       - 'requirements-mkdocs.in'
       - 'requirements-mkdocs.txt'

.github/workflows/publish-kernel.yml

@@ -62,9 +62,8 @@ jobs:
               cuda-version: '13.0.0'
               torch-cuda-short: 'cu130'
           platform:
-            # x86_64 builds the full cu126 + cu130 set. cu130 ships the
-            # data-center Blackwell sm_100a VSA and consumer sm_120a FP4
-            # kernels.
+            # x86_64 builds the full cu126 + cu130 set (cu130 ships the consumer
+            # Blackwell sm_120a FP4 kernels).
             - os: ubuntu-22.04
               arch: x86_64
               wheel-plat: manylinux_2_35_x86_64
@@ -125,7 +124,7 @@ jobs:
       - name: Install dependencies (GCC, Clang, CUDA Paths, Git)
         run: |
           sudo apt update
-          sudo apt install -y git gcc-11 g++-11 clang-11
+          sudo apt install -y git patchelf gcc-11 g++-11 clang-11
           sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 100 --slave /usr/bin/g++ g++ /usr/bin/g++-11
 
           # Allow Git to Access Safe Directory
@@ -169,8 +168,7 @@ jobs:
           #     covers sm_120a; turbodiffusion covers sm_100a+sm_120a. The sm_100 FP4
           #     forward is the FA4 CuTe DSL path in the fastvideo package (PR #1221),
           #     JIT-compiled at runtime — not built into this wheel.
-          #   * x86_64 cu130 = Hopper TK + data-center Blackwell sm_100a VSA
-          #     + consumer Blackwell sm_120a FP4.
+          #   * x86_64 cu130 = Hopper TK + consumer Blackwell sm_120a FP4.
           #   * x86_64 cu126 = Hopper TK only (older drivers; CUDA < 12.8 has no FP4).
           # The per-arch split in CMakeLists pins the FP4 targets to sm_120a and builds
           # the main extension for the full arch list. CMAKE_BUILD_PARALLEL_LEVEL caps
@@ -180,7 +178,7 @@ jobs:
             export CMAKE_ARGS="${CMAKE_ARGS:-} -DFASTVIDEO_KERNEL_BUILD_TK=OFF -DFASTVIDEO_KERNEL_BUILD_ATTN_QAT_INFER=ON"
             export CMAKE_BUILD_PARALLEL_LEVEL=1
           elif [ "${{ matrix.torch-cuda.torch-cuda-short }}" = "cu130" ]; then
-            export TORCH_CUDA_ARCH_LIST="9.0a;10.0a;12.0a"
+            export TORCH_CUDA_ARCH_LIST="9.0a;12.0a"
             export CMAKE_ARGS="${CMAKE_ARGS:-} -DFASTVIDEO_KERNEL_BUILD_TK=ON -DFASTVIDEO_KERNEL_BUILD_ATTN_QAT_INFER=ON -DCMAKE_CUDA_ARCHITECTURES=90a"
             # A single FP4 TU (attn_qat_infer) can use ~8-12 GB on its own, so serialize.
             export CMAKE_BUILD_PARALLEL_LEVEL=1
@@ -196,11 +194,7 @@ jobs:
           python -m build --wheel --outdir dist
 
           # Fix the wheel to be manylinux compliant
-          # Ubuntu 22.04 ships patchelf 0.14.3, while current auditwheel
-          # requires at least 0.14.5. Use the stable PyPI binary on both
-          # x86_64 and aarch64 release runners.
-          uv pip install --system auditwheel patchelf==0.17.2.4
-          patchelf --version
+          uv pip install --system auditwheel
           # Point auditwheel at torch libs, but do not vendor them into the wheel.
           TORCH_LIB_DIR=$(python - <<'PY'
           import os
@@ -217,8 +211,7 @@ jobs:
             --exclude libtorch.so \
             --exclude libc10.so \
             --exclude libc10_cuda.so \
-            --exclude libtorch_python.so \
-            --exclude libnccl.so.2
+            --exclude libtorch_python.so
           # Move fixed wheels back to dist for upload consistency
           rm dist/*.whl
           mv fixed_dist/*.whl dist/

.gitignore

@@ -23,7 +23,6 @@ Miniconda3-latest-Linux-x86_64.sh
 *validation/
 data/
 outputs/
-outputs_audio/
 outputs_video
 checkpoints/
 sbatch.sh

.pre-commit-config.yaml

@@ -22,7 +22,6 @@ repos:
   hooks:
   - id: yapf
     args: [--in-place, --verbose]
-    language_version: python3.12
     additional_dependencies: [toml] # TODO: Remove when yapf is upgraded
 - repo: https://github.com/astral-sh/ruff-pre-commit
   rev: v0.11.12

README.md

@@ -9,8 +9,6 @@
 **FastVideo is a unified post-training and real-time inference framework for accelerated video generation.**
 
 ## NEWS
-- `2026/08/23`: [FastH3 Preview v0.2](https://huggingface.co/FastVideo/FastVideo-Minimax-FastH3-Preview-v0.2) is a 4-step DMD2-distilled MiniMax-H3 checkpoint that generates synchronized video and audio. Run the verified [basic FastH3 example](examples/inference/basic/basic_fasth3.py), see the [inference guide](examples/inference/basic/README.md#fasth3-preview), or have a coding agent install FastVideo with the [agent setup prompt](#install-with-an-ai-coding-agent).
-- `2026/08/19`: FastVideo now supports MLX on Apple Silicon with [FastMetal-QAD](https://huggingface.co/collections/FastVideo/fastmetal), a family of 1.3B, 5B, and 14B models optimized for Mac—follow the [Apple Silicon guide](https://hao-ai-lab.github.io/FastVideo/getting_started/installation/mps/) and read the [Blog](https://haoailab.com/blogs/fastmetal/).
 - `2026/06/23`: Release FastWan-QAD: 5s of Video generated in 1.8s E2E. See the [FastWan-QAD models](https://huggingface.co/FastVideo/FastWan-QAD-FP8-1.3B), [Attn-QAT training guide](https://haoailab.com/FastVideo/training/attn_qat/), and [blog](https://haoailab.com/blogs/fastwan-qad/).
 - `2026/03/17`: Release demo: Into the Dreamverse: Vibe Directing in FastVideo, check out the [Blog](https://haoailab.com/blogs/dreamverse/).
 - `2026/03/13`: Release demo: Create a 5s 1080p Video in 4.5s with FastVideo on a Single GPU, check out the [Blog](https://haoailab.com/blogs/fastvideo_realtime_1080p/).
@@ -64,12 +62,6 @@ UV_TORCH_BACKEND=cu126 uv pip install fastvideo
 Use `UV_TORCH_BACKEND=cu130` on CUDA 13. Apple silicon users should follow the
 [MPS installation guide](https://hao-ai-lab.github.io/FastVideo/getting_started/installation/mps/).
 
-> **On an Apple Silicon Mac?** FastVideo runs FastMetal-QAD through an MLX
-> runtime. Install with `uv pip install -e '.[mlx]'`, download
-> [`FastVideo/FastMetal-1.3B-QAD`](https://huggingface.co/FastVideo/FastMetal-1.3B-QAD),
-> and follow the
-> [Apple Silicon guide](https://hao-ai-lab.github.io/FastVideo/getting_started/installation/mps/).
-
 Please see our [docs](https://hao-ai-lab.github.io/FastVideo/getting_started/installation/) for more detailed installation instructions.
 
 > **On an NVIDIA DGX Spark (GB10 / ARM64 + CUDA 13)?** There's no prebuilt ARM wheel for the FastVideo CUDA kernel, so it's an editable from-source install (`UV_TORCH_BACKEND=cu130 uv pip install -e .`, which compiles that kernel for you) rather than `UV_TORCH_BACKEND=cu130 uv pip install fastvideo`. A compatible prebuilt ARM64 FlashAttention wheel is available separately. Follow the [DGX Spark install guide](https://hao-ai-lab.github.io/FastVideo/getting_started/installation/spark/).

apps/dreamverse/dreamverse/tests/conftest.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import sys
 from pathlib import Path
 
+
 TESTS_DIR = Path(__file__).resolve().parent
 DREAMVERSE_PACKAGE_DIR = TESTS_DIR.parent
 DREAMVERSE_APP_DIR = DREAMVERSE_PACKAGE_DIR.parent

apps/dreamverse/dreamverse/tests/test_config.py

@@ -5,6 +5,7 @@ from pathlib import Path
 
 import pytest
 
+
 SERVER_DIR = Path(__file__).resolve().parents[1]
 
 
@@ -52,7 +53,9 @@ def test_config_defaults_to_cerebras_with_parallel_groq_fallback_stage(monkeypat
     module = _load_config_module()
 
     assert module.PROMPT_PROVIDER == "cerebras"
-    assert module.PROMPT_PROVIDER_RUNTIME_STAGES == (("cerebras", "groq"), )
+    assert module.PROMPT_PROVIDER_RUNTIME_STAGES == (
+        ("cerebras", "groq"),
+    )
     assert module.PROMPT_PROVIDER_PRIORITY == (
         "cerebras",
         "groq",
@@ -83,7 +86,9 @@ def test_config_ignores_legacy_groq_primary_override(monkeypatch):
     module = _load_config_module()
 
     assert module.PROMPT_PROVIDER == "cerebras"
-    assert module.PROMPT_PROVIDER_RUNTIME_STAGES == (("cerebras", "groq"), )
+    assert module.PROMPT_PROVIDER_RUNTIME_STAGES == (
+        ("cerebras", "groq"),
+    )
     assert module.PROMPT_PROVIDER_PRIORITY == (
         "cerebras",
         "groq",
@@ -101,17 +106,24 @@ def test_config_uses_local_overlay_paths_when_devtools_enabled(monkeypatch, tmp_
 
     assert module.DEVTOOLS_ENABLED is True
     assert module.FRONTEND_ROOT.as_posix().endswith("apps/dreamverse/web")
-    assert module.PROMPT_ENHANCE_SYSTEM_PROMPT_PATH.endswith("dreamverse/prompts.local/next_segment_system_prompt.md")
+    assert module.PROMPT_ENHANCE_SYSTEM_PROMPT_PATH.endswith(
+        "dreamverse/prompts.local/next_segment_system_prompt.md"
+    )
     assert module.PROMPT_ENHANCE_SYSTEM_PROMPT_FALLBACK_PATH.endswith(
-        "dreamverse/prompts/next_segment_system_prompt.md")
+        "dreamverse/prompts/next_segment_system_prompt.md"
+    )
     assert module.PROMPT_REWRITE_USER_SYSTEM_PROMPT_PATH.endswith(
-        "dreamverse/prompts.local/rewrite_user_system_prompt.md")
+        "dreamverse/prompts.local/rewrite_user_system_prompt.md"
+    )
     assert module.PROMPT_REWRITE_USER_SYSTEM_PROMPT_FALLBACK_PATH.endswith(
-        "dreamverse/prompts/rewrite_user_system_prompt.md")
+        "dreamverse/prompts/rewrite_user_system_prompt.md"
+    )
     assert module.CURATED_PRESETS_FILE_PATH.endswith(
-        "apps/dreamverse/web/prompts.local/selected_ltx2_continuation_story_presets.json")
+        "apps/dreamverse/web/prompts.local/selected_ltx2_continuation_story_presets.json"
+    )
     assert module.CURATED_PRESETS_FALLBACK_FILE_PATH.endswith(
-        "apps/dreamverse/web/prompts/selected_ltx2_continuation_story_presets.json")
+        "apps/dreamverse/web/prompts/selected_ltx2_continuation_story_presets.json"
+    )
     assert module.FRONTEND_STATIC_DIR_CANDIDATES[:2] == (
         str(module.FRONTEND_ROOT / "out"),
         str(module.FRONTEND_ROOT / "dist"),

apps/dreamverse/dreamverse/tests/test_entrypoints.py

@@ -9,7 +9,6 @@ from fastapi.testclient import TestClient
 import fastvideo.entrypoints.streaming as streaming_entrypoints
 import pytest
 
-
 def _install_stack03_import_stubs(monkeypatch):
     """Keep entrypoint tests focused while later-stack runtime modules are absent."""
     if not hasattr(streaming_entrypoints, "build_health_router"):
@@ -18,7 +17,6 @@ def _install_stack03_import_stubs(monkeypatch):
     gpu_pool_stub = types.ModuleType("dreamverse.gpu_pool")
 
     class GPUPool:
-
         def __init__(self, _gpu_ids):
             pass
 
@@ -51,7 +49,6 @@ def _install_stack03_import_stubs(monkeypatch):
     controller_stub = types.ModuleType("dreamverse.session.controller")
 
     class SessionController:
-
         def __init__(self, **_kwargs):
             pass
 
@@ -79,11 +76,13 @@ def _run_cli(module, monkeypatch, argv: list[str]) -> list[dict[str, object]]:
     uvicorn_stub = types.ModuleType("uvicorn")
 
     def run(app, host: str, port: int) -> None:
-        calls.append({
-            "app": app,
-            "host": host,
-            "port": port,
-        })
+        calls.append(
+            {
+                "app": app,
+                "host": host,
+                "port": port,
+            }
+        )
 
     uvicorn_stub.run = run
     monkeypatch.setitem(sys.modules, "uvicorn", uvicorn_stub)
@@ -100,11 +99,13 @@ def test_server_cli_defaults_to_local_web_port(monkeypatch):
     server_main = _import_server_main(monkeypatch)
     calls = _run_cli(server_main, monkeypatch, ["dreamverse-server"])
 
-    assert calls == [{
-        "app": server_main.app,
-        "host": "0.0.0.0",
-        "port": 8009,
-    }]
+    assert calls == [
+        {
+            "app": server_main.app,
+            "host": "0.0.0.0",
+            "port": 8009,
+        }
+    ]
 
 
 def test_server_cli_allows_explicit_host_and_port(monkeypatch):
@@ -115,11 +116,13 @@ def test_server_cli_allows_explicit_host_and_port(monkeypatch):
         ["dreamverse-server", "--host", "127.0.0.1", "--port", "8123"],
     )
 
-    assert calls == [{
-        "app": server_main.app,
-        "host": "127.0.0.1",
-        "port": 8123,
-    }]
+    assert calls == [
+        {
+            "app": server_main.app,
+            "host": "127.0.0.1",
+            "port": 8123,
+        }
+    ]
 
 
 def test_server_does_not_expose_backend_source_as_static_assets(monkeypatch):
@@ -139,11 +142,13 @@ def test_mock_server_cli_defaults_to_local_web_port(monkeypatch):
         ["dreamverse-mock-server"],
     )
 
-    assert calls == [{
-        "app": mock_server.app,
-        "host": "0.0.0.0",
-        "port": 8009,
-    }]
+    assert calls == [
+        {
+            "app": mock_server.app,
+            "host": "0.0.0.0",
+            "port": 8009,
+        }
+    ]
 
 
 def test_mock_server_cli_updates_latency(monkeypatch):
@@ -156,11 +161,13 @@ def test_mock_server_cli_updates_latency(monkeypatch):
             ["dreamverse-mock-server", "--latency", "321", "--port", "8111"],
         )
 
-        assert calls == [{
-            "app": mock_server.app,
-            "host": "0.0.0.0",
-            "port": 8111,
-        }]
+        assert calls == [
+            {
+                "app": mock_server.app,
+                "host": "0.0.0.0",
+                "port": 8111,
+            }
+        ]
         assert mock_server.LATENCY_MS == 321
     finally:
         mock_server.LATENCY_MS = old_latency_ms

apps/dreamverse/dreamverse/tests/test_gpu_pool.py

@@ -7,6 +7,7 @@ from types import SimpleNamespace
 
 import pytest
 
+
 import dreamverse.gpu_pool as gpu_pool
 
 
@@ -84,7 +85,9 @@ def test_send_command_raises_on_worker_death():
     cmd_q = ctx.Queue()
     resp_q = ctx.Queue()
 
-    proc = ctx.Process(target=_child_consume_and_exit, args=(cmd_q, resp_q))
+    proc = ctx.Process(
+        target=_child_consume_and_exit, args=(cmd_q, resp_q)
+    )
     proc.start()
 
     # Wait for the spawn child to fully boot.  Allow generous time —

apps/dreamverse/dreamverse/tests/test_import_contract.py

@@ -7,7 +7,7 @@ ALLOWED_PREFIXES = (
     "fastvideo.entrypoints.video_generator",
     "fastvideo.configs",
 )
-ALLOWED_EXACT = ("fastvideo", )
+ALLOWED_EXACT = ("fastvideo",)
 FORBIDDEN_PREFIXES = (
     "fastvideo.pipelines",
     "fastvideo.models",
@@ -38,13 +38,19 @@ def test_dreamverse_server_imports_only_public_fastvideo_surfaces() -> None:
         except SyntaxError as task_exc:
             raise AssertionError(f"Failed to parse {path}") from task_exc
         for node in ast.walk(tree):
-            names = ([a.name for a in node.names] if isinstance(node, ast.Import) else
-                     [node.module] if isinstance(node, ast.ImportFrom) and node.module else [])
+            names = (
+                [a.name for a in node.names] if isinstance(node, ast.Import)
+                else [node.module] if isinstance(node, ast.ImportFrom) and node.module
+                else []
+            )
             for name in names:
                 if not name:
                     continue
                 rel_path = str(path.relative_to(root))
-                if (name.startswith(FORBIDDEN_PREFIXES) and (rel_path, name) not in ALLOWED_INTERNAL_IMPORTS):
+                if (
+                    name.startswith(FORBIDDEN_PREFIXES)
+                    and (rel_path, name) not in ALLOWED_INTERNAL_IMPORTS
+                ):
                     bad.append((str(path.relative_to(root)), getattr(node, "lineno", 0), name))
 
     assert bad == [], f"Forbidden internal imports: {bad}"

apps/dreamverse/dreamverse/tests/test_mock_server.py

@@ -6,6 +6,7 @@ import os
 
 from fastapi import WebSocketDisconnect
 
+
 os.environ.setdefault("CEREBRAS_API_KEY", "dummy")
 os.environ.setdefault("GROQ_API_KEY", "dummy")
 
@@ -13,7 +14,6 @@ import dreamverse.mock_server as mock_server
 
 
 class _FakeWebSocket:
-
     def __init__(self, messages: list[tuple[float, dict[str, object]]]):
         self._messages = messages
         self._index = 0
@@ -49,34 +49,34 @@ def test_mock_server_matches_current_single5s_protocol():
         mock_server.MOCK_SEGMENT_BYTES = b"mock-fmp4-bytes"
         mock_server.LATENCY_MS = 1
 
-        ws = _FakeWebSocket([
-            (
-                0.0,
-                {
-                    "type": "session_init_v2",
-                    "preset_id": "simple_prompt_1",
-                    "curated_prompts": ["selected prompt"],
-                    "single_clip_mode": True,
-                    "enhancement_enabled": False,
-                    "auto_extension_enabled": False,
-                    "loop_generation_enabled": False,
-                },
-            ),
-            (
-                0.01,
-                {
-                    "type": "simple_generate",
-                    "preset_id": "simple_custom_prompt",
-                    "prompt_id": "simple_custom_prompt",
-                    "prompt": "custom prompt",
-                    "enhancement_enabled": True,
-                    "initial_image": None,
-                },
-            ),
-            (0.20, {
-                "type": "leave"
-            }),
-        ])
+        ws = _FakeWebSocket(
+            [
+                (
+                    0.0,
+                    {
+                        "type": "session_init_v2",
+                        "preset_id": "simple_prompt_1",
+                        "curated_prompts": ["selected prompt"],
+                        "single_clip_mode": True,
+                        "enhancement_enabled": False,
+                        "auto_extension_enabled": False,
+                        "loop_generation_enabled": False,
+                    },
+                ),
+                (
+                    0.01,
+                    {
+                        "type": "simple_generate",
+                        "preset_id": "simple_custom_prompt",
+                        "prompt_id": "simple_custom_prompt",
+                        "prompt": "custom prompt",
+                        "enhancement_enabled": True,
+                        "initial_image": None,
+                    },
+                ),
+                (0.20, {"type": "leave"}),
+            ]
+        )
 
         asyncio.run(mock_server.websocket_endpoint(ws))
 
@@ -92,14 +92,24 @@ def test_mock_server_matches_current_single5s_protocol():
         assert message_types.count("ltx2_stream_complete") == 2
         assert "prompt_sources_blocked" not in message_types
 
-        segment_start_events = [payload for payload in ws.sent_json if payload["type"] == "ltx2_segment_start"]
-        gpu_assigned_event = next(payload for payload in ws.sent_json if payload["type"] == "gpu_assigned")
+        segment_start_events = [
+            payload
+            for payload in ws.sent_json
+            if payload["type"] == "ltx2_segment_start"
+        ]
+        gpu_assigned_event = next(
+            payload for payload in ws.sent_json if payload["type"] == "gpu_assigned"
+        )
         assert gpu_assigned_event["session_timeout"] == mock_server.SESSION_TIMEOUT_SECONDS
         assert [payload["segment_idx"] for payload in segment_start_events] == [1, 1]
         assert segment_start_events[0]["prompt"] == "selected prompt"
         assert segment_start_events[1]["prompt"] == "custom prompt"
 
-        step_complete_events = [payload for payload in ws.sent_json if payload["type"] == "step_complete"]
+        step_complete_events = [
+            payload
+            for payload in ws.sent_json
+            if payload["type"] == "step_complete"
+        ]
         assert len(step_complete_events) == 2
         assert step_complete_events[0]["latency_ms"] == {
             "total": 121.0,
@@ -124,29 +134,29 @@ def test_mock_server_regular_cap_waits_for_rewrite_rollout():
         mock_server.LATENCY_MS = 1
         mock_server.GENERATION_SEGMENT_CAP = 1
 
-        ws = _FakeWebSocket([
-            (
-                0.0,
-                {
-                    "type": "session_init_v2",
-                    "preset_id": "test_preset",
-                    "curated_prompts": ["segment one"],
-                    "enhancement_enabled": True,
-                    "auto_extension_enabled": False,
-                    "loop_generation_enabled": False,
-                },
-            ),
-            (
-                0.02,
-                {
-                    "type": "rewrite_seed_prompts",
-                    "rewrite_instruction": "start a new rollout",
-                },
-            ),
-            (0.20, {
-                "type": "leave"
-            }),
-        ])
+        ws = _FakeWebSocket(
+            [
+                (
+                    0.0,
+                    {
+                        "type": "session_init_v2",
+                        "preset_id": "test_preset",
+                        "curated_prompts": ["segment one"],
+                        "enhancement_enabled": True,
+                        "auto_extension_enabled": False,
+                        "loop_generation_enabled": False,
+                    },
+                ),
+                (
+                    0.02,
+                    {
+                        "type": "rewrite_seed_prompts",
+                        "rewrite_instruction": "start a new rollout",
+                    },
+                ),
+                (0.20, {"type": "leave"}),
+            ]
+        )
 
         asyncio.run(mock_server.websocket_endpoint(ws))
 
@@ -156,7 +166,11 @@ def test_mock_server_regular_cap_waits_for_rewrite_rollout():
         assert "generation_cap_reached" not in message_types
         assert "prompt_sources_blocked" not in message_types
 
-        segment_start_events = [payload for payload in ws.sent_json if payload["type"] == "ltx2_segment_start"]
+        segment_start_events = [
+            payload
+            for payload in ws.sent_json
+            if payload["type"] == "ltx2_segment_start"
+        ]
         assert [payload["segment_idx"] for payload in segment_start_events] == [1, 1]
         assert segment_start_events[0]["prompt"] == "segment one"
         assert segment_start_events[1]["prompt"] == "segment one [start a new rollout]"
@@ -173,40 +187,54 @@ def test_mock_server_rewrite_during_active_segment_restarts_from_first_rewritten
         mock_server.MOCK_SEGMENT_BYTES = b"mock-fmp4-bytes"
         mock_server.LATENCY_MS = 100
 
-        ws = _FakeWebSocket([
-            (
-                0.0,
-                {
-                    "type": "session_init_v2",
-                    "preset_id": "test_preset",
-                    "curated_prompts": ["segment one", "segment two"],
-                    "enhancement_enabled": True,
-                    "auto_extension_enabled": False,
-                    "loop_generation_enabled": False,
-                },
-            ),
-            (
-                0.02,
-                {
-                    "type": "rewrite_seed_prompts",
-                    "rewrite_instruction": "restart from rewrite",
-                },
-            ),
-            (0.40, {
-                "type": "leave"
-            }),
-        ])
+        ws = _FakeWebSocket(
+            [
+                (
+                    0.0,
+                    {
+                        "type": "session_init_v2",
+                        "preset_id": "test_preset",
+                        "curated_prompts": ["segment one", "segment two"],
+                        "enhancement_enabled": True,
+                        "auto_extension_enabled": False,
+                        "loop_generation_enabled": False,
+                    },
+                ),
+                (
+                    0.02,
+                    {
+                        "type": "rewrite_seed_prompts",
+                        "rewrite_instruction": "restart from rewrite",
+                    },
+                ),
+                (0.40, {"type": "leave"}),
+            ]
+        )
 
         asyncio.run(mock_server.websocket_endpoint(ws))
 
-        segment_start_events = [payload for payload in ws.sent_json if payload["type"] == "ltx2_segment_start"]
+        segment_start_events = [
+            payload
+            for payload in ws.sent_json
+            if payload["type"] == "ltx2_segment_start"
+        ]
         assert [payload["prompt"] for payload in segment_start_events[:2]] == [
             "segment one",
             "segment one [restart from rewrite]",
         ]
-        assert all(payload["prompt"] != "segment two" for payload in segment_start_events[1:])
-        reset_events = [payload for payload in ws.sent_json if payload.get("type") == "seed_prompts_reset_applied"]
-        assert any(payload.get("reason") == "rewrite_during_generation" for payload in reset_events)
+        assert all(
+            payload["prompt"] != "segment two"
+            for payload in segment_start_events[1:]
+        )
+        reset_events = [
+            payload
+            for payload in ws.sent_json
+            if payload.get("type") == "seed_prompts_reset_applied"
+        ]
+        assert any(
+            payload.get("reason") == "rewrite_during_generation"
+            for payload in reset_events
+        )
     finally:
         mock_server.MOCK_SEGMENT_BYTES = old_segment_bytes
         mock_server.LATENCY_MS = old_latency_ms
@@ -219,24 +247,24 @@ def test_mock_server_supports_initial_custom_rollout_prompt():
         mock_server.MOCK_SEGMENT_BYTES = b"mock-fmp4-bytes"
         mock_server.LATENCY_MS = 1
 
-        ws = _FakeWebSocket([
-            (
-                0.0,
-                {
-                    "type": "session_init_v2",
-                    "preset_id": "custom_editable",
-                    "preset_label": "Custom rollout",
-                    "curated_prompts": [],
-                    "initial_rollout_prompt": "A moonbase corridor thriller with flooding",
-                    "enhancement_enabled": True,
-                    "auto_extension_enabled": False,
-                    "loop_generation_enabled": False,
-                },
-            ),
-            (0.20, {
-                "type": "leave"
-            }),
-        ])
+        ws = _FakeWebSocket(
+            [
+                (
+                    0.0,
+                    {
+                        "type": "session_init_v2",
+                        "preset_id": "custom_editable",
+                        "preset_label": "Custom rollout",
+                        "curated_prompts": [],
+                        "initial_rollout_prompt": "A moonbase corridor thriller with flooding",
+                        "enhancement_enabled": True,
+                        "auto_extension_enabled": False,
+                        "loop_generation_enabled": False,
+                    },
+                ),
+                (0.20, {"type": "leave"}),
+            ]
+        )
 
         asyncio.run(mock_server.websocket_endpoint(ws))
 
@@ -248,9 +276,15 @@ def test_mock_server_supports_initial_custom_rollout_prompt():
         assert "ltx2_stream_start" in message_types
         assert "prompt_sources_blocked" not in message_types
 
-        segment_start_events = [payload for payload in ws.sent_json if payload["type"] == "ltx2_segment_start"]
+        segment_start_events = [
+            payload
+            for payload in ws.sent_json
+            if payload["type"] == "ltx2_segment_start"
+        ]
         assert segment_start_events
-        assert segment_start_events[0]["prompt"] == ("A moonbase corridor thriller with flooding [segment 1]")
+        assert segment_start_events[0]["prompt"] == (
+            "A moonbase corridor thriller with flooding [segment 1]"
+        )
     finally:
         mock_server.MOCK_SEGMENT_BYTES = old_segment_bytes
         mock_server.LATENCY_MS = old_latency_ms
@@ -263,37 +297,35 @@ def test_mock_server_can_start_new_project_without_reconnecting():
         mock_server.MOCK_SEGMENT_BYTES = b"mock-fmp4-bytes"
         mock_server.LATENCY_MS = 40
 
-        ws = _FakeWebSocket([
-            (
-                0.0,
-                {
-                    "type": "session_init_v2",
-                    "preset_id": "test_preset",
-                    "curated_prompts": ["segment one"],
-                    "enhancement_enabled": True,
-                    "auto_extension_enabled": False,
-                    "loop_generation_enabled": False,
-                },
-            ),
-            (0.02, {
-                "type": "end_project_keep_session"
-            }),
-            (
-                0.20,
-                {
-                    "type": "project_init_v1",
-                    "preset_id": "test_preset_2",
-                    "preset_label": "Test Preset 2",
-                    "curated_prompts": ["segment two"],
-                    "enhancement_enabled": True,
-                    "auto_extension_enabled": False,
-                    "loop_generation_enabled": False,
-                },
-            ),
-            (0.40, {
-                "type": "leave"
-            }),
-        ])
+        ws = _FakeWebSocket(
+            [
+                (
+                    0.0,
+                    {
+                        "type": "session_init_v2",
+                        "preset_id": "test_preset",
+                        "curated_prompts": ["segment one"],
+                        "enhancement_enabled": True,
+                        "auto_extension_enabled": False,
+                        "loop_generation_enabled": False,
+                    },
+                ),
+                (0.02, {"type": "end_project_keep_session"}),
+                (
+                    0.20,
+                    {
+                        "type": "project_init_v1",
+                        "preset_id": "test_preset_2",
+                        "preset_label": "Test Preset 2",
+                        "curated_prompts": ["segment two"],
+                        "enhancement_enabled": True,
+                        "auto_extension_enabled": False,
+                        "loop_generation_enabled": False,
+                    },
+                ),
+                (0.40, {"type": "leave"}),
+            ]
+        )
 
         asyncio.run(mock_server.websocket_endpoint(ws))
 
@@ -304,11 +336,16 @@ def test_mock_server_can_start_new_project_without_reconnecting():
 
         project_idle_index = message_types.index("project_idle")
         stream_start_indexes = [
-            index for index, message_type in enumerate(message_types) if message_type == "ltx2_stream_start"
+            index for index, message_type in enumerate(message_types)
+            if message_type == "ltx2_stream_start"
         ]
         assert stream_start_indexes[0] < project_idle_index < stream_start_indexes[1]
 
-        segment_start_events = [payload for payload in ws.sent_json if payload["type"] == "ltx2_segment_start"]
+        segment_start_events = [
+            payload
+            for payload in ws.sent_json
+            if payload["type"] == "ltx2_segment_start"
+        ]
         assert [payload["prompt"] for payload in segment_start_events[:2]] == [
             "segment one",
             "segment two",

apps/dreamverse/dreamverse/tests/test_prompt_enhancer.py

@@ -6,6 +6,7 @@ import os
 import re
 import time
 
+
 os.environ.setdefault("CEREBRAS_API_KEY", "dummy")
 os.environ.setdefault("GROQ_API_KEY", "dummy")
 
@@ -21,7 +22,6 @@ from dreamverse.prompt_enhancer import (
 
 
 class _FakeResponse:
-
     def __init__(self, payload: dict):
         self._payload = payload
 
@@ -30,7 +30,6 @@ class _FakeResponse:
 
 
 class _FakeSyncCompletions:
-
     def __init__(self, payload: dict):
         self._payload = payload
 
@@ -39,7 +38,6 @@ class _FakeSyncCompletions:
 
 
 class _FakeSyncClient:
-
     def __init__(self, payload: dict):
         self.chat = type(
             "_FakeChat",
@@ -49,7 +47,6 @@ class _FakeSyncClient:
 
 
 class _DelayedSyncCompletions:
-
     def __init__(self, payload: dict, delay_s: float = 0.0, exc: Exception | None = None):
         self._payload = payload
         self._delay_s = delay_s
@@ -64,26 +61,29 @@ class _DelayedSyncCompletions:
 
 
 class _DelayedSyncClient:
-
     def __init__(self, payload: dict, delay_s: float = 0.0, exc: Exception | None = None):
         self.chat = type(
             "_FakeChat",
             (),
-            {"completions": _DelayedSyncCompletions(
-                payload,
-                delay_s=delay_s,
-                exc=exc,
-            )},
+            {
+                "completions": _DelayedSyncCompletions(
+                    payload,
+                    delay_s=delay_s,
+                    exc=exc,
+                )
+            },
         )()
 
 
 def _chat_payload_with_content(content: str) -> dict:
     return {
-        "choices": [{
-            "message": {
-                "content": content,
+        "choices": [
+            {
+                "message": {
+                    "content": content,
+                }
             }
-        }]
+        ]
     }
 
 
@@ -172,7 +172,6 @@ def _build_staged_enhancer(
 
 
 class _FakeOpenAIClient:
-
     def __init__(self, **kwargs):
         self.kwargs = kwargs
         self.chat = type(
@@ -183,7 +182,6 @@ class _FakeOpenAIClient:
 
 
 class _FakeCerebrasClient:
-
     def __init__(self, **kwargs):
         self.kwargs = kwargs
         self.chat = type(
@@ -194,12 +192,16 @@ class _FakeCerebrasClient:
 
 
 def test_parse_json_response_accepts_fenced_json_with_prose():
-    parsed = _parse_json_response("Here is the rewrite:\n```json\n{\"segment_prompts\":[\"A\",\"B\"]}\n```\nThanks.")
+    parsed = _parse_json_response(
+        "Here is the rewrite:\n```json\n{\"segment_prompts\":[\"A\",\"B\"]}\n```\nThanks."
+    )
     assert parsed == {"segment_prompts": ["A", "B"]}
 
 
 def test_parse_json_response_extracts_first_embedded_object():
-    parsed = _parse_json_response("Model output:\n{\"segment_prompts\":[\"A\",\"B\"]}\n(complete)")
+    parsed = _parse_json_response(
+        "Model output:\n{\"segment_prompts\":[\"A\",\"B\"]}\n(complete)"
+    )
     assert parsed == {"segment_prompts": ["A", "B"]}
 
 
@@ -266,12 +268,16 @@ def test_build_client_supports_groq_provider(monkeypatch):
 
 def test_rewrite_prompt_sequence_accepts_segment_prompts_output():
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     result = asyncio.run(
         enhancer.rewrite_prompt_sequence(
             ["prompt one", "prompt two"],
             rewrite_instruction="make it cinematic",
-        ))
+        )
+    )
     assert result.fallback_used is False
     assert result.error is None
     assert result.rollout_id == "preset_a"
@@ -280,12 +286,15 @@ def test_rewrite_prompt_sequence_accepts_segment_prompts_output():
 
 
 def test_rewrite_prompt_sequence_accepts_legacy_rewritten_prompts_output():
-    enhancer = _build_test_enhancer(_chat_payload_with_content('{"rewritten_prompts":["A","B"]}'))
+    enhancer = _build_test_enhancer(
+        _chat_payload_with_content('{"rewritten_prompts":["A","B"]}')
+    )
     result = asyncio.run(
         enhancer.rewrite_prompt_sequence(
             ["prompt one", "prompt two"],
             rewrite_instruction="make it cinematic",
-        ))
+        )
+    )
     assert result.fallback_used is False
     assert result.error is None
     assert result.rollout_id == "current_rollout"
@@ -294,14 +303,19 @@ def test_rewrite_prompt_sequence_accepts_legacy_rewritten_prompts_output():
 
 
 def test_rewrite_prompt_sequence_accepts_segment_dicts_without_top_level_rollout_metadata():
-    enhancer = _build_test_enhancer(_chat_payload_with_content('{"segments":[{"prompt":"A"},{"text":"B"}]}'))
+    enhancer = _build_test_enhancer(
+        _chat_payload_with_content(
+            '{"segments":[{"prompt":"A"},{"text":"B"}]}'
+        )
+    )
     result = asyncio.run(
         enhancer.rewrite_prompt_sequence(
             ["prompt one", "prompt two"],
             preset_id="preset_a",
             preset_label="Preset A",
             rewrite_instruction="make it cinematic",
-        ))
+        )
+    )
     assert result.fallback_used is False
     assert result.error is None
     assert result.rollout_id == "preset_a"
@@ -315,12 +329,14 @@ def test_rewrite_prompt_sequence_accepts_numbered_prose_output():
             "The user is asking for a cinematic rewrite.\n\n"
             "1. A dog bounds across the moon's dusty surface, kicking up silver regolith as it chases a rabbit beneath the black sky.\n"
             "2. The rabbit darts around a crater rim while the dog lunges after it, Earth glowing blue in the distance.\n"
-        ))
+        )
+    )
     result = asyncio.run(
         enhancer.rewrite_prompt_sequence(
             ["prompt one", "prompt two"],
             rewrite_instruction="make it cinematic",
-        ))
+        )
+    )
     assert result.fallback_used is False
     assert result.error is None
     assert result.rollout_id == "current_rollout"
@@ -339,10 +355,12 @@ def test_enhance_prompt_prefers_cerebras_before_groq_fallback():
         groq_delay_s=0.01,
     )
 
-    result = asyncio.run(enhancer.enhance_prompt(
-        "A rainy alley at night",
-        mode="single_clip",
-    ))
+    result = asyncio.run(
+        enhancer.enhance_prompt(
+            "A rainy alley at night",
+            mode="single_clip",
+        )
+    )
 
     assert result.fallback_used is False
     assert result.error is None
@@ -363,10 +381,12 @@ def test_enhance_prompt_uses_groq_when_cerebras_fails():
         groq_delay_s=0.01,
     )
 
-    result = asyncio.run(enhancer.enhance_prompt(
-        "A rainy alley at night",
-        mode="single_clip",
-    ))
+    result = asyncio.run(
+        enhancer.enhance_prompt(
+            "A rainy alley at night",
+            mode="single_clip",
+        )
+    )
 
     assert result.fallback_used is False
     assert result.error is None
@@ -388,11 +408,13 @@ def test_enhance_prompt_can_use_groq_when_cerebras_times_out():
     enhancer.http_timeout_ms = 50
     enhancer.default_timeout_ms = 50
 
-    result = asyncio.run(enhancer.enhance_prompt(
-        "A rainy alley at night",
-        mode="single_clip",
-        timeout_ms=50,
-    ))
+    result = asyncio.run(
+        enhancer.enhance_prompt(
+            "A rainy alley at night",
+            mode="single_clip",
+            timeout_ms=50,
+        )
+    )
 
     assert result.fallback_used is False
     assert result.error is None
@@ -412,10 +434,12 @@ def test_enhance_prompt_can_use_cerebras_when_it_returns_first():
         groq_delay_s=0.08,
     )
 
-    result = asyncio.run(enhancer.enhance_prompt(
-        "A rainy alley at night",
-        mode="single_clip",
-    ))
+    result = asyncio.run(
+        enhancer.enhance_prompt(
+            "A rainy alley at night",
+            mode="single_clip",
+        )
+    )
 
     assert result.fallback_used is False
     assert result.error is None
@@ -429,12 +453,15 @@ def test_enhance_prompt_can_use_cerebras_when_it_returns_first():
 
 
 def test_rewrite_prompt_sequence_keeps_raw_output_on_parse_error():
-    enhancer = _build_test_enhancer(_chat_payload_with_content("I cannot comply with JSON right now."))
+    enhancer = _build_test_enhancer(
+        _chat_payload_with_content("I cannot comply with JSON right now.")
+    )
     result = asyncio.run(
         enhancer.rewrite_prompt_sequence(
             ["prompt one", "prompt two"],
             rewrite_instruction="make it cinematic",
-        ))
+        )
+    )
     assert result.fallback_used is True
     assert "No JSON object found in assistant response." in (result.error or "")
     assert result.raw_response_text == "I cannot comply with JSON right now."
@@ -446,7 +473,9 @@ def test_rewrite_prompt_sequence_keeps_raw_output_on_parse_error():
 def test_rewrite_prompt_sequence_uses_current_rollout_payload_shape():
     enhancer = _build_test_enhancer(
         _chat_payload_with_content(
-            '{"id":"rewritten_rollout","label":"Rewritten Rollout","segment_prompts":["A","B"]}'))
+            '{"id":"rewritten_rollout","label":"Rewritten Rollout","segment_prompts":["A","B"]}'
+        )
+    )
     captured = {
         "body": None,
         "timeout_seconds": None,
@@ -457,7 +486,8 @@ def test_rewrite_prompt_sequence_uses_current_rollout_payload_shape():
         captured["timeout_seconds"] = timeout_seconds
         return (
             _chat_payload_with_content(
-                '{"id":"rewritten_rollout","label":"Rewritten Rollout","segment_prompts":["A","B"]}'),
+                '{"id":"rewritten_rollout","label":"Rewritten Rollout","segment_prompts":["A","B"]}'
+            ),
             '{"id":"rewritten_rollout","label":"Rewritten Rollout","segment_prompts":["A","B"]}',
         )
 
@@ -472,7 +502,8 @@ def test_rewrite_prompt_sequence_uses_current_rollout_payload_shape():
             rewrite_model="gpt-test",
             rewrite_temperature=0.2,
             timeout_ms=800,
-        ))
+        )
+    )
 
     assert result.fallback_used is False
     assert captured["body"]["messages"][0] == {
@@ -481,12 +512,12 @@ def test_rewrite_prompt_sequence_uses_current_rollout_payload_shape():
     }
     assert captured["body"]["messages"][1]["role"] == "user"
     assert prompt_enhancer_module.json.loads(captured["body"]["messages"][1]["content"]) == {
-        "mode":
-        "edit_existing_rollout",
-        "request": ("Rewrite all segment prompts with improved continuity and cinematic detail. "
-                    "Keep count and ordering identical."),
-        "user_instruction":
-        "make it cinematic",
+        "mode": "edit_existing_rollout",
+        "request": (
+            "Rewrite all segment prompts with improved continuity and cinematic detail. "
+            "Keep count and ordering identical."
+        ),
+        "user_instruction": "make it cinematic",
         "current_rollout": {
             "id": "preset_a",
             "label": "Preset A",
@@ -497,8 +528,11 @@ def test_rewrite_prompt_sequence_uses_current_rollout_payload_shape():
 
 def test_rewrite_prompt_sequence_supports_new_rollout_mode():
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"custom_editable","label":"Custom rollout","segment_prompts":['
-                                   '"A","B","C","D","E","F"]}'))
+        _chat_payload_with_content(
+            '{"id":"custom_editable","label":"Custom rollout","segment_prompts":['
+            '"A","B","C","D","E","F"]}'
+        )
+    )
     captured = {
         "body": None,
     }
@@ -507,8 +541,10 @@ def test_rewrite_prompt_sequence_supports_new_rollout_mode():
         del timeout_seconds
         captured["body"] = body
         return (
-            _chat_payload_with_content('{"id":"custom_editable","label":"Custom rollout","segment_prompts":['
-                                       '"A","B","C","D","E","F"]}'),
+            _chat_payload_with_content(
+                '{"id":"custom_editable","label":"Custom rollout","segment_prompts":['
+                '"A","B","C","D","E","F"]}'
+            ),
             '{"id":"custom_editable","label":"Custom rollout","segment_prompts":['
             '"A","B","C","D","E","F"]}',
         )
@@ -524,29 +560,30 @@ def test_rewrite_prompt_sequence_supports_new_rollout_mode():
             rewrite_model="gpt-test",
             rewrite_temperature=0.2,
             timeout_ms=800,
-        ))
+        )
+    )
 
     assert result.fallback_used is False
     assert result.prompts == ["A", "B", "C", "D", "E", "F"]
     assert prompt_enhancer_module.json.loads(captured["body"]["messages"][1]["content"]) == {
-        "mode":
-        "new_rollout",
-        "request": ("Rewrite all segment prompts with improved continuity and cinematic detail. "
-                    "Keep count and ordering identical."),
-        "user_instruction":
-        "A moonbase corridor thriller with flooding and red alarms",
-        "desired_segment_count":
-        6,
-        "rollout_id_hint":
-        "custom_editable",
-        "rollout_label_hint":
-        "Custom rollout",
+        "mode": "new_rollout",
+        "request": (
+            "Rewrite all segment prompts with improved continuity and cinematic detail. "
+            "Keep count and ordering identical."
+        ),
+        "user_instruction": "A moonbase corridor thriller with flooding and red alarms",
+        "desired_segment_count": 6,
+        "rollout_id_hint": "custom_editable",
+        "rollout_label_hint": "Custom rollout",
     }
 
 
 def test_rewrite_prompt_sequence_uses_session_override_system_prompt():
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     enhancer.rewrite_all_system_prompt = "shared system prompt"
     captured = {
         "body": None,
@@ -556,7 +593,9 @@ def test_rewrite_prompt_sequence_uses_session_override_system_prompt():
         del timeout_seconds
         captured["body"] = body
         return (
-            _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'),
+            _chat_payload_with_content(
+                '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+            ),
             '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}',
         )
 
@@ -570,7 +609,8 @@ def test_rewrite_prompt_sequence_uses_session_override_system_prompt():
             rewrite_instruction="make it cinematic",
             rewrite_model="gpt-test",
             system_prompt_override="session specific system prompt",
-        ))
+        )
+    )
 
     assert result.fallback_used is False
     assert captured["body"]["messages"][0] == {
@@ -581,7 +621,10 @@ def test_rewrite_prompt_sequence_uses_session_override_system_prompt():
 
 def test_resolve_rewrite_new_rollout_system_prompt_uses_dedicated_prompt():
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     enhancer.rewrite_all_system_prompt = "shared rewrite system prompt"
     enhancer.rewrite_user_system_prompt = "new rollout rewrite system prompt"
 
@@ -592,17 +635,24 @@ def test_resolve_rewrite_new_rollout_system_prompt_uses_dedicated_prompt():
 
 def test_resolve_rewrite_new_rollout_system_prompt_prefers_override():
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     enhancer.rewrite_all_system_prompt = "shared rewrite system prompt"
     enhancer.rewrite_user_system_prompt = "new rollout rewrite system prompt"
 
-    resolved = enhancer.resolve_rewrite_new_rollout_system_prompt("session specific system prompt")
+    resolved = enhancer.resolve_rewrite_new_rollout_system_prompt(
+        "session specific system prompt"
+    )
 
     assert resolved == "session specific system prompt"
 
 
 def test_generate_auto_prompt_uses_selected_model():
-    enhancer = _build_test_enhancer(_chat_payload_with_content('{"next_prompt":"Auto next"}'))
+    enhancer = _build_test_enhancer(
+        _chat_payload_with_content('{"next_prompt":"Auto next"}')
+    )
     enhancer.auto_system_prompt = "auto system prompt"
     enhancer.rewrite_model_options = ["gpt-test", "gpt-alt"]
     enhancer.rewrite_default_model = "gpt-test"
@@ -630,7 +680,8 @@ def test_generate_auto_prompt_uses_selected_model():
             next_segment_idx=2,
             model="gpt-alt",
             timeout_ms=800,
-        ))
+        )
+    )
     assert result.fallback_used is False
     assert result.error is None
     assert result.prompt == "Auto next"
@@ -639,7 +690,9 @@ def test_generate_auto_prompt_uses_selected_model():
 
 
 def test_enhance_prompt_uses_selected_model():
-    enhancer = _build_test_enhancer(_chat_payload_with_content('{"next_prompt":"Enhanced next"}'))
+    enhancer = _build_test_enhancer(
+        _chat_payload_with_content('{"next_prompt":"Enhanced next"}')
+    )
     enhancer.enhance_system_prompt = "enhance system prompt"
     enhancer.auto_system_prompt = "auto system prompt"
     enhancer.rewrite_model_options = ["gpt-test", "gpt-alt"]
@@ -669,7 +722,8 @@ def test_enhance_prompt_uses_selected_model():
             next_segment_idx=2,
             model="gpt-alt",
             timeout_ms=800,
-        ))
+        )
+    )
     assert result.fallback_used is False
     assert result.error is None
     assert result.prompt == "Enhanced next"
@@ -678,7 +732,9 @@ def test_enhance_prompt_uses_selected_model():
 
 
 def test_enhance_prompt_single_clip_uses_auto_extension_prompt_and_prompt_field():
-    enhancer = _build_test_enhancer(_chat_payload_with_content('{"prompt":"Extended single clip"}'))
+    enhancer = _build_test_enhancer(
+        _chat_payload_with_content('{"prompt":"Extended single clip"}')
+    )
     enhancer.enhance_system_prompt = "enhance system prompt"
     enhancer.auto_system_prompt = "auto system prompt"
     enhancer.rewrite_model_options = ["gpt-test", "gpt-alt"]
@@ -708,12 +764,14 @@ def test_enhance_prompt_single_clip_uses_auto_extension_prompt_and_prompt_field(
 
     enhancer._request_content = _fake_request_content  # type: ignore[attr-defined]
 
-    result = asyncio.run(enhancer.enhance_prompt(
-        "short 5s idea",
-        mode="single_clip",
-        model="gpt-alt",
-        timeout_ms=800,
-    ))
+    result = asyncio.run(
+        enhancer.enhance_prompt(
+            "short 5s idea",
+            mode="single_clip",
+            model="gpt-alt",
+            timeout_ms=800,
+        )
+    )
     assert result.fallback_used is False
     assert result.error is None
     assert result.prompt == "Extended single clip"
@@ -726,15 +784,17 @@ def test_enhance_prompt_single_clip_uses_auto_extension_prompt_and_prompt_field(
             "single 5-second LTX-2.3 video clip. Respond with "
             'valid JSON only as {"prompt": "..."}.'  # noqa: E501
         ),
-        "user_prompt":
-        "short 5s idea",
+        "user_prompt": "short 5s idea",
     }
 
 
 def test_enhance_prompt_single_clip_rejects_plain_text_response():
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content("Medium shot of a woman by a rainy cafe window as she lifts her "
-                                   "phone, exhales softly, and the camera makes a slow push in."))
+        _chat_payload_with_content(
+            "Medium shot of a woman by a rainy cafe window as she lifts her "
+            "phone, exhales softly, and the camera makes a slow push in."
+        )
+    )
     enhancer.auto_system_prompt = "auto system prompt"
 
     result = asyncio.run(
@@ -743,14 +803,17 @@ def test_enhance_prompt_single_clip_rejects_plain_text_response():
             mode="single_clip",
             model="gpt-test",
             timeout_ms=800,
-        ))
+        )
+    )
     assert result.fallback_used is True
     assert "No JSON object found in assistant response." in result.error
     assert result.prompt == ""
 
 
 def test_enhance_prompt_single_clip_rejects_segment_prompts_json():
-    enhancer = _build_test_enhancer(_chat_payload_with_content('{"segment_prompts":["A","B"]}'))
+    enhancer = _build_test_enhancer(
+        _chat_payload_with_content('{"segment_prompts":["A","B"]}')
+    )
     enhancer.auto_system_prompt = "auto system prompt"
     enhancer.rewrite_model_options = ["gpt-test"]
     enhancer.rewrite_default_model = "gpt-test"
@@ -761,14 +824,17 @@ def test_enhance_prompt_single_clip_rejects_segment_prompts_json():
             mode="single_clip",
             model="gpt-test",
             timeout_ms=800,
-        ))
+        )
+    )
     assert result.fallback_used is True
     assert result.prompt == ""
     assert "Missing prompt string." in (result.error or "")
 
 
 def test_enhance_prompt_requires_json_and_does_not_fallback_to_raw_text():
-    enhancer = _build_test_enhancer(_chat_payload_with_content("A cinematic continuation with slow dolly movement."))
+    enhancer = _build_test_enhancer(
+        _chat_payload_with_content("A cinematic continuation with slow dolly movement.")
+    )
     enhancer.enhance_system_prompt = "enhance system prompt"
     enhancer.rewrite_model_options = ["gpt-test"]
     enhancer.rewrite_default_model = "gpt-test"
@@ -780,14 +846,17 @@ def test_enhance_prompt_requires_json_and_does_not_fallback_to_raw_text():
             next_segment_idx=2,
             model="gpt-test",
             timeout_ms=800,
-        ))
+        )
+    )
     assert result.fallback_used is True
     assert result.prompt == ""
     assert "No JSON object found in assistant response." in (result.error or "")
 
 
 def test_generate_auto_prompt_requires_json_and_does_not_fallback_to_raw_text():
-    enhancer = _build_test_enhancer(_chat_payload_with_content("A calm, grounded continuation with subtle motion."))
+    enhancer = _build_test_enhancer(
+        _chat_payload_with_content("A calm, grounded continuation with subtle motion.")
+    )
     enhancer.auto_system_prompt = "auto system prompt"
     enhancer.rewrite_model_options = ["gpt-test"]
     enhancer.rewrite_default_model = "gpt-test"
@@ -798,30 +867,34 @@ def test_generate_auto_prompt_requires_json_and_does_not_fallback_to_raw_text():
             next_segment_idx=2,
             model="gpt-test",
             timeout_ms=800,
-        ))
+        )
+    )
     assert result.fallback_used is True
     assert result.prompt == ""
     assert "No JSON object found in assistant response." in (result.error or "")
 
 
 def test_rewrite_prompt_sequence_includes_raw_json_when_content_empty():
-    enhancer = _build_test_enhancer({
-        "choices": [{
-            "finish_reason": "length",
-            "message": {
-                "content": [],
-                "refusal": None,
-            },
-        }],
-        "usage": {
-            "completion_tokens": 0
-        },
-    })
+    enhancer = _build_test_enhancer(
+        {
+            "choices": [
+                {
+                    "finish_reason": "length",
+                    "message": {
+                        "content": [],
+                        "refusal": None,
+                    },
+                }
+            ],
+            "usage": {"completion_tokens": 0},
+        }
+    )
     result = asyncio.run(
         enhancer.rewrite_prompt_sequence(
             ["prompt one", "prompt two"],
             rewrite_instruction="make it cinematic",
-        ))
+        )
+    )
     assert result.fallback_used is True
     assert "No rewrite segment prompts found in assistant response." in (result.error or "")
     assert isinstance(result.raw_response_text, str)
@@ -830,7 +903,10 @@ def test_rewrite_prompt_sequence_includes_raw_json_when_content_empty():
 
 def test_get_rewrite_model_config_returns_fixed_defaults():
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     enhancer.rewrite_default_model = "gpt-oss-120b"
     enhancer.rewrite_model_options = ["gpt-oss-120b"]
 
@@ -842,7 +918,10 @@ def test_get_rewrite_model_config_returns_fixed_defaults():
 
 def test_get_prompt_config_includes_auto_extension_prompt():
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     enhancer.enhance_system_prompt_path = "/tmp/next.md"
     enhancer.auto_system_prompt_path = "/tmp/auto.md"
     enhancer.rewrite_all_system_prompt_path = "/tmp/rewrite.md"
@@ -869,14 +948,19 @@ def test_get_prompt_config_includes_auto_extension_prompt():
 
 def test_get_prompt_config_reports_loaded_fallback_prompt_path(tmp_path):
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     rewrite_fallback_path = tmp_path / "rewrite_window_system_prompt.md"
     rewrite_fallback_path.write_text("rewrite prompt\n", encoding="utf-8")
     next_path = tmp_path / "next.md"
     next_path.write_text("next prompt\n", encoding="utf-8")
     auto_path = tmp_path / "auto.md"
     auto_path.write_text("auto prompt\n", encoding="utf-8")
-    enhancer.rewrite_all_system_prompt_path = str(tmp_path / "prompts.local" / "rewrite_window_system_prompt.md")
+    enhancer.rewrite_all_system_prompt_path = str(
+        tmp_path / "prompts.local" / "rewrite_window_system_prompt.md"
+    )
     enhancer.rewrite_all_system_prompt_fallback_path = str(rewrite_fallback_path)
     enhancer.enhance_system_prompt_path = str(next_path)
     enhancer.auto_system_prompt_path = str(auto_path)
@@ -889,9 +973,14 @@ def test_get_prompt_config_reports_loaded_fallback_prompt_path(tmp_path):
     assert config["rewrite_window_system_prompt_path"] == str(rewrite_fallback_path)
 
 
-def test_reload_system_prompts_falls_back_to_rewrite_window_when_user_prompt_empty(tmp_path, ):
+def test_reload_system_prompts_falls_back_to_rewrite_window_when_user_prompt_empty(
+    tmp_path,
+):
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     next_path = tmp_path / "next.md"
     auto_path = tmp_path / "auto.md"
     rewrite_path = tmp_path / "rewrite_window_system_prompt.md"
@@ -918,7 +1007,10 @@ def test_reload_system_prompts_falls_back_to_rewrite_window_when_user_prompt_emp
 
 def test_save_prompt_config_updates_auto_extension_prompt(tmp_path):
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     next_path = tmp_path / "next.md"
     auto_path = tmp_path / "auto.md"
     rewrite_path = tmp_path / "rewrite.md"
@@ -929,7 +1021,9 @@ def test_save_prompt_config_updates_auto_extension_prompt(tmp_path):
     enhancer.auto_system_prompt_path = str(auto_path)
     enhancer.rewrite_all_system_prompt_path = str(rewrite_path)
 
-    config = enhancer.save_prompt_config(auto_extension_system_prompt="auto updated", )
+    config = enhancer.save_prompt_config(
+        auto_extension_system_prompt="auto updated",
+    )
 
     assert auto_path.read_text(encoding="utf-8").strip() == "auto updated"
     assert config["auto_extension_system_prompt"] == "auto updated"
@@ -937,7 +1031,10 @@ def test_save_prompt_config_updates_auto_extension_prompt(tmp_path):
 
 def test_save_prompt_config_updates_rewrite_user_prompt(tmp_path):
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     next_path = tmp_path / "next.md"
     auto_path = tmp_path / "auto.md"
     rewrite_path = tmp_path / "rewrite.md"
@@ -955,7 +1052,9 @@ def test_save_prompt_config_updates_rewrite_user_prompt(tmp_path):
     enhancer.rewrite_all_system_prompt_fallback_path = None
     enhancer.rewrite_user_system_prompt_fallback_path = None
 
-    config = enhancer.save_prompt_config(rewrite_user_system_prompt="rewrite user updated", )
+    config = enhancer.save_prompt_config(
+        rewrite_user_system_prompt="rewrite user updated",
+    )
 
     assert rewrite_user_path.read_text(encoding="utf-8").strip() == "rewrite user updated"
     assert config["rewrite_user_system_prompt"] == "rewrite user updated"
@@ -963,7 +1062,10 @@ def test_save_prompt_config_updates_rewrite_user_prompt(tmp_path):
 
 def test_save_prompt_config_updates_rewrite_model(tmp_path):
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     next_path = tmp_path / "next.md"
     auto_path = tmp_path / "auto.md"
     rewrite_path = tmp_path / "rewrite.md"
@@ -979,7 +1081,9 @@ def test_save_prompt_config_updates_rewrite_model(tmp_path):
     enhancer.rewrite_default_model = "gpt-test"
     enhancer.rewrite_model_options = ["gpt-test", "gpt-alt"]
 
-    config = enhancer.save_prompt_config(rewrite_model="gpt-alt", )
+    config = enhancer.save_prompt_config(
+        rewrite_model="gpt-alt",
+    )
 
     assert enhancer.rewrite_default_model == "gpt-alt"
     assert config["rewrite_model"] == "gpt-alt"
@@ -988,7 +1092,10 @@ def test_save_prompt_config_updates_rewrite_model(tmp_path):
 
 def test_save_prompt_config_updates_rewrite_temperature(tmp_path):
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     next_path = tmp_path / "next.md"
     auto_path = tmp_path / "auto.md"
     rewrite_path = tmp_path / "rewrite.md"
@@ -1002,7 +1109,9 @@ def test_save_prompt_config_updates_rewrite_temperature(tmp_path):
     enhancer.auto_system_prompt_fallback_path = None
     enhancer.rewrite_all_system_prompt_fallback_path = None
 
-    config = enhancer.save_prompt_config(rewrite_temperature=1.3, )
+    config = enhancer.save_prompt_config(
+        rewrite_temperature=1.3,
+    )
 
     assert enhancer.rewrite_default_temperature == 1.3
     assert config["rewrite_temperature"] == 1.3
@@ -1010,7 +1119,10 @@ def test_save_prompt_config_updates_rewrite_temperature(tmp_path):
 
 def test_save_prompt_config_creates_versioned_backup_for_existing_prompt(tmp_path):
     enhancer = _build_test_enhancer(
-        _chat_payload_with_content('{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'))
+        _chat_payload_with_content(
+            '{"id":"preset_a","label":"Preset A","segment_prompts":["A","B"]}'
+        )
+    )
     next_path = tmp_path / "next.md"
     auto_path = tmp_path / "auto.md"
     rewrite_path = tmp_path / "rewrite_window_system_prompt.md"
@@ -1024,9 +1136,13 @@ def test_save_prompt_config_creates_versioned_backup_for_existing_prompt(tmp_pat
     enhancer.auto_system_prompt_fallback_path = None
     enhancer.rewrite_all_system_prompt_fallback_path = None
 
-    enhancer.save_prompt_config(rewrite_window_system_prompt="rewrite updated", )
+    enhancer.save_prompt_config(
+        rewrite_window_system_prompt="rewrite updated",
+    )
 
-    backup_paths = sorted(tmp_path.glob("rewrite_window_system_prompt.*.bak.md"))
+    backup_paths = sorted(
+        tmp_path.glob("rewrite_window_system_prompt.*.bak.md")
+    )
 
     assert rewrite_path.read_text(encoding="utf-8").strip() == "rewrite updated"
     assert len(backup_paths) == 1

apps/dreamverse/dreamverse/tests/test_realtime_stress.py

@@ -27,8 +27,13 @@ try:
 except ModuleNotFoundError:
     websockets = None  # type: ignore[assignment]
 
-DEFAULT_PRESET_FILE = (Path(__file__).resolve().parents[2] / "web" / "prompts" /
-                       "selected_ltx2_continuation_story_presets.json")
+
+DEFAULT_PRESET_FILE = (
+    Path(__file__).resolve().parents[2]
+    / "web"
+    / "prompts"
+    / "selected_ltx2_continuation_story_presets.json"
+)
 
 
 def utc_now_iso() -> str:
@@ -60,7 +65,10 @@ def safe_percentile(values: list[float], percentile: float) -> float | None:
     if lower == upper:
         return sorted_values[lower]
     fraction = rank - lower
-    return (sorted_values[lower] + (sorted_values[upper] - sorted_values[lower]) * fraction)
+    return (
+        sorted_values[lower]
+        + (sorted_values[upper] - sorted_values[lower]) * fraction
+    )
 
 
 def summarize_series(values: list[float]) -> dict[str, float | int | None]:
@@ -137,16 +145,24 @@ def load_curated_prompts(
     selected_id = str(selected.get("id", "")).strip() or "unknown_preset"
     raw_prompts = selected.get("segment_prompts", [])
     if not isinstance(raw_prompts, list):
-        raise ValueError(f"Preset {selected_id} has invalid segment_prompts (must be list).")
+        raise ValueError(
+            f"Preset {selected_id} has invalid segment_prompts (must be list)."
+        )
 
-    prompts = [str(prompt).strip() for prompt in raw_prompts if isinstance(prompt, str) and str(prompt).strip()]
+    prompts = [
+        str(prompt).strip()
+        for prompt in raw_prompts
+        if isinstance(prompt, str) and str(prompt).strip()
+    ]
     if not prompts:
         raise ValueError(f"Preset {selected_id} has no non-empty prompts.")
 
     limited = prompts[:curated_limit]
     if not limited:
-        raise ValueError(f"curated_limit={curated_limit} produced no prompts for preset "
-                         f"{selected_id}.")
+        raise ValueError(
+            f"curated_limit={curated_limit} produced no prompts for preset "
+            f"{selected_id}."
+        )
     return selected_id, limited, len(prompts)
 
 
@@ -208,11 +224,11 @@ async def run_single_session(
 
     try:
         async with websockets.connect(
-                url,
-                max_size=None,
-                ping_interval=None,
-                open_timeout=connect_timeout_s,
-                close_timeout=2.0,
+            url,
+            max_size=None,
+            ping_interval=None,
+            open_timeout=connect_timeout_s,
+            close_timeout=2.0,
         ) as ws:
             connect_finish_monotonic = time.monotonic()
             session_data["connect_finish_ts_utc"] = utc_now_iso()
@@ -233,7 +249,9 @@ async def run_single_session(
                 timeout_remaining = session_timeout_s - elapsed_s
                 if timeout_remaining <= 0:
                     session_data["status"] = "timeout"
-                    session_data["error"] = (f"Session timed out after {session_timeout_s:.1f}s.")
+                    session_data["error"] = (
+                        f"Session timed out after {session_timeout_s:.1f}s."
+                    )
                     break
 
                 recv_start_epoch = time.time()
@@ -247,7 +265,9 @@ async def run_single_session(
                     )
                 except asyncio.TimeoutError:
                     session_data["status"] = "timeout"
-                    session_data["error"] = ("Timed out waiting for websocket message.")
+                    session_data["error"] = (
+                        "Timed out waiting for websocket message."
+                    )
                     break
                 except Exception as exc:
                     session_data["status"] = "failed"
@@ -268,16 +288,20 @@ async def run_single_session(
 
                     chunk_gap_ms: float | None = None
                     if last_chunk_finish_monotonic is not None:
-                        chunk_gap_ms = (recv_finish_monotonic - last_chunk_finish_monotonic) * 1000.0
+                        chunk_gap_ms = (
+                            recv_finish_monotonic - last_chunk_finish_monotonic
+                        ) * 1000.0
 
-                    session_data["chunks"].append({
-                        "segment_idx": current_segment_idx,
-                        "chunk_idx": session_data["total_chunks"],
-                        "size_bytes": len(message),
-                        "chunk_start_ts_utc": recv_start_iso,
-                        "chunk_finish_ts_utc": recv_finish_iso,
-                        "chunk_gap_ms": chunk_gap_ms,
-                    })
+                    session_data["chunks"].append(
+                        {
+                            "segment_idx": current_segment_idx,
+                            "chunk_idx": session_data["total_chunks"],
+                            "size_bytes": len(message),
+                            "chunk_start_ts_utc": recv_start_iso,
+                            "chunk_finish_ts_utc": recv_finish_iso,
+                            "chunk_gap_ms": chunk_gap_ms,
+                        }
+                    )
                     last_chunk_finish_monotonic = recv_finish_monotonic
                     last_chunk_finish_epoch = recv_finish_epoch
                     session_data["last_chunk_finish_ts_utc"] = recv_finish_iso
@@ -297,7 +321,9 @@ async def run_single_session(
                 if msg_type == "gpu_assigned":
                     session_data["gpu_assigned_ts_utc"] = recv_finish_iso
                     if connect_finish_monotonic is not None:
-                        session_data["queue_wait_ms"] = (recv_finish_monotonic - connect_finish_monotonic) * 1000.0
+                        session_data["queue_wait_ms"] = (
+                            recv_finish_monotonic - connect_finish_monotonic
+                        ) * 1000.0
                 elif msg_type == "ltx2_stream_start":
                     if initial_total_segments is None:
                         parsed_total = parse_int(data.get("total_segments"))
@@ -312,13 +338,20 @@ async def run_single_session(
                     session_data["media_segments_completed"] += 1
                     if first_media_segment_complete_epoch is None:
                         first_media_segment_complete_epoch = recv_finish_epoch
-                        session_data["first_media_segment_complete_ts_utc"] = recv_finish_iso
+                        session_data[
+                            "first_media_segment_complete_ts_utc"
+                        ] = recv_finish_iso
                 elif msg_type == "ltx2_segment_complete":
                     session_data["segments_completed"] += 1
                     seg_idx = parse_int(data.get("segment_idx"))
-                    if (initial_total_segments is not None and seg_idx is not None
-                            and seg_idx >= initial_total_segments):
-                        session_data["target_segment_complete_ts_utc"] = recv_finish_iso
+                    if (
+                        initial_total_segments is not None
+                        and seg_idx is not None
+                        and seg_idx >= initial_total_segments
+                    ):
+                        session_data[
+                            "target_segment_complete_ts_utc"
+                        ] = recv_finish_iso
                         await asyncio.sleep(post_complete_wait_s)
                         session_data["leave_sent_ts_utc"] = utc_now_iso()
                         try:
@@ -329,11 +362,15 @@ async def run_single_session(
                         break
                 elif msg_type == "session_timeout":
                     session_data["status"] = "timeout"
-                    session_data["error"] = str(data.get("message") or "Backend session timeout")
+                    session_data["error"] = str(
+                        data.get("message") or "Backend session timeout"
+                    )
                     break
                 elif msg_type == "error":
                     session_data["status"] = "failed"
-                    session_data["error"] = str(data.get("message") or "Backend error message")
+                    session_data["error"] = str(
+                        data.get("message") or "Backend error message"
+                    )
                     break
 
             if session_data["status"] == "failed" and session_data["error"] is None:
@@ -342,18 +379,29 @@ async def run_single_session(
         session_data["status"] = "failed"
         session_data["error"] = f"WebSocket connect/run failed: {exc}"
 
-    if (first_chunk_finish_epoch is not None and last_chunk_finish_epoch is not None
-            and session_data["total_chunk_bytes"] > 0):
+    if (
+        first_chunk_finish_epoch is not None
+        and last_chunk_finish_epoch is not None
+        and session_data["total_chunk_bytes"] > 0
+    ):
         duration_s = last_chunk_finish_epoch - first_chunk_finish_epoch
         if duration_s > 0:
-            session_data["session_goodput_mbps"] = (session_data["total_chunk_bytes"] * 8.0 / duration_s / 1_000_000.0)
+            session_data["session_goodput_mbps"] = (
+                session_data["total_chunk_bytes"] * 8.0 / duration_s / 1_000_000.0
+            )
 
-    if (first_chunk_finish_epoch is not None and first_media_segment_complete_epoch is not None):
-        session_data["first_chunk_before_first_media_complete"] = (first_chunk_finish_epoch
-                                                                   < first_media_segment_complete_epoch)
+    if (
+        first_chunk_finish_epoch is not None
+        and first_media_segment_complete_epoch is not None
+    ):
+        session_data["first_chunk_before_first_media_complete"] = (
+            first_chunk_finish_epoch < first_media_segment_complete_epoch
+        )
 
     session_data["close_ts_utc"] = utc_now_iso()
-    session_data["duration_ms"] = (time.monotonic() - session_start_monotonic) * 1000.0
+    session_data["duration_ms"] = (
+        time.monotonic() - session_start_monotonic
+    ) * 1000.0
     return session_data
 
 
@@ -364,11 +412,14 @@ async def run_worker_sessions(
     config: dict[str, Any],
 ) -> list[dict[str, Any]]:
     tasks = [
-        asyncio.create_task(run_single_session(
-            worker_id=worker_id,
-            worker_session_idx=idx,
-            config=config,
-        )) for idx in range(session_count)
+        asyncio.create_task(
+            run_single_session(
+                worker_id=worker_id,
+                worker_session_idx=idx,
+                config=config,
+            )
+        )
+        for idx in range(session_count)
     ]
     if not tasks:
         return []
@@ -386,23 +437,29 @@ def worker_entry(
     try:
         ready_queue.put({"worker_id": worker_id, "status": "ready"})
         start_event.wait()
-        sessions = asyncio.run(run_worker_sessions(
-            worker_id=worker_id,
-            session_count=session_count,
-            config=config,
-        ))
-        result_queue.put({
-            "worker_id": worker_id,
-            "status": "ok",
-            "sessions": sessions,
-        })
+        sessions = asyncio.run(
+            run_worker_sessions(
+                worker_id=worker_id,
+                session_count=session_count,
+                config=config,
+            )
+        )
+        result_queue.put(
+            {
+                "worker_id": worker_id,
+                "status": "ok",
+                "sessions": sessions,
+            }
+        )
     except Exception as exc:
-        result_queue.put({
-            "worker_id": worker_id,
-            "status": "error",
-            "error": str(exc),
-            "traceback": traceback.format_exc(),
-        })
+        result_queue.put(
+            {
+                "worker_id": worker_id,
+                "status": "error",
+                "error": str(exc),
+                "traceback": traceback.format_exc(),
+            }
+        )
 
 
 def build_summary(
@@ -460,22 +517,33 @@ def build_summary(
     if len(all_chunk_finish_epochs) >= 2 and total_chunk_bytes > 0:
         duration_s = max(all_chunk_finish_epochs) - min(all_chunk_finish_epochs)
         if duration_s > 0:
-            global_goodput_mbps = (total_chunk_bytes * 8.0 / duration_s / 1_000_000.0)
+            global_goodput_mbps = (
+                total_chunk_bytes * 8.0 / duration_s / 1_000_000.0
+            )
 
-    bucket_throughputs_mbps = [(bytes_count * 8.0) / 1_000_000.0 for _, bytes_count in sorted(bucket_bytes.items())]
+    bucket_throughputs_mbps = [
+        (bytes_count * 8.0) / 1_000_000.0
+        for _, bytes_count in sorted(bucket_bytes.items())
+    ]
     bucket_stats = summarize_series(bucket_throughputs_mbps)
 
-    chunk_gap_threshold_breaches = [value for value in chunk_gaps if value >= chunk_gap_threshold_ms]
+    chunk_gap_threshold_breaches = [
+        value for value in chunk_gaps if value >= chunk_gap_threshold_ms
+    ]
     non_success = len(sessions) - status_counts.get("success", 0)
 
     fail_reasons: list[str] = []
     if non_success > 0:
-        fail_reasons.append(f"{non_success} session(s) did not complete successfully.")
+        fail_reasons.append(
+            f"{non_success} session(s) did not complete successfully."
+        )
     if not chunk_gaps:
         fail_reasons.append("No chunk gap data collected.")
     if chunk_gap_threshold_breaches:
-        fail_reasons.append(f"{len(chunk_gap_threshold_breaches)} chunk gap(s) were >= "
-                            f"{chunk_gap_threshold_ms:.0f}ms.")
+        fail_reasons.append(
+            f"{len(chunk_gap_threshold_breaches)} chunk gap(s) were >= "
+            f"{chunk_gap_threshold_ms:.0f}ms."
+        )
 
     passed = len(fail_reasons) == 0
     progressive_ratio = None
@@ -486,18 +554,20 @@ def build_summary(
         "passed": passed,
         "fail_reasons": fail_reasons,
         "sessions": {
-            "total":
-            len(sessions),
-            "success":
-            status_counts.get("success", 0),
-            "failed":
-            status_counts.get("failed", 0),
-            "timeout":
-            status_counts.get("timeout", 0),
-            "protocol_error":
-            status_counts.get("protocol_error", 0),
-            "other": (len(sessions) - (status_counts.get("success", 0) + status_counts.get("failed", 0) +
-                                       status_counts.get("timeout", 0) + status_counts.get("protocol_error", 0))),
+            "total": len(sessions),
+            "success": status_counts.get("success", 0),
+            "failed": status_counts.get("failed", 0),
+            "timeout": status_counts.get("timeout", 0),
+            "protocol_error": status_counts.get("protocol_error", 0),
+            "other": (
+                len(sessions)
+                - (
+                    status_counts.get("success", 0)
+                    + status_counts.get("failed", 0)
+                    + status_counts.get("timeout", 0)
+                    + status_counts.get("protocol_error", 0)
+                )
+            ),
         },
         "chunk_gap_ms": {
             **chunk_gap_stats,
@@ -536,39 +606,51 @@ def print_summary(
     bucket_bw = bandwidth["bucketed_1s"]
 
     print("=== LTX2 Realtime Stress Test Summary ===")
-    print("Run: "
-          f"url={run_info['url']} clients={run_info['clients']} "
-          f"processes={run_info['processes']} "
-          f"preset={run_info['preset_id']} "
-          f"curated_limit={run_info['curated_limit']}")
-    print("Sessions: "
-          f"total={sessions['total']} success={sessions['success']} "
-          f"failed={sessions['failed']} timeout={sessions['timeout']} "
-          f"protocol_error={sessions['protocol_error']}")
-    print("Chunk gap ms: "
-          f"min={format_num(chunk_gap['min'])} "
-          f"p50={format_num(chunk_gap['p50'])} "
-          f"p95={format_num(chunk_gap['p95'])} "
-          f"p99={format_num(chunk_gap['p99'])} "
-          f"max={format_num(chunk_gap['max'])} "
-          f"threshold={format_num(chunk_gap['threshold_ms'])} "
-          f"breaches={chunk_gap['breach_count']}")
-    print("Queue wait ms: "
-          f"min={format_num(queue_wait['min'])} "
-          f"p50={format_num(queue_wait['p50'])} "
-          f"p95={format_num(queue_wait['p95'])} "
-          f"max={format_num(queue_wait['max'])}")
+    print(
+        "Run: "
+        f"url={run_info['url']} clients={run_info['clients']} "
+        f"processes={run_info['processes']} "
+        f"preset={run_info['preset_id']} "
+        f"curated_limit={run_info['curated_limit']}"
+    )
+    print(
+        "Sessions: "
+        f"total={sessions['total']} success={sessions['success']} "
+        f"failed={sessions['failed']} timeout={sessions['timeout']} "
+        f"protocol_error={sessions['protocol_error']}"
+    )
+    print(
+        "Chunk gap ms: "
+        f"min={format_num(chunk_gap['min'])} "
+        f"p50={format_num(chunk_gap['p50'])} "
+        f"p95={format_num(chunk_gap['p95'])} "
+        f"p99={format_num(chunk_gap['p99'])} "
+        f"max={format_num(chunk_gap['max'])} "
+        f"threshold={format_num(chunk_gap['threshold_ms'])} "
+        f"breaches={chunk_gap['breach_count']}"
+    )
+    print(
+        "Queue wait ms: "
+        f"min={format_num(queue_wait['min'])} "
+        f"p50={format_num(queue_wait['p50'])} "
+        f"p95={format_num(queue_wait['p95'])} "
+        f"max={format_num(queue_wait['max'])}"
+    )
     ratio = progressive["ratio"]
     ratio_text = "n/a" if ratio is None else f"{ratio * 100:.2f}%"
-    print("Progressive streaming: "
-          f"{progressive['success_sessions']}/"
-          f"{progressive['eligible_sessions']} ({ratio_text})")
-    print("Bandwidth Mbps: "
-          f"per_session_avg={format_num(per_session_bw['avg'])} "
-          f"per_session_p95={format_num(per_session_bw['p95'])} "
-          f"global={format_num(bandwidth['global_goodput_mbps'])} "
-          f"bucket_avg={format_num(bucket_bw['avg_mbps'])} "
-          f"bucket_peak={format_num(bucket_bw['peak_mbps'])}")
+    print(
+        "Progressive streaming: "
+        f"{progressive['success_sessions']}/"
+        f"{progressive['eligible_sessions']} ({ratio_text})"
+    )
+    print(
+        "Bandwidth Mbps: "
+        f"per_session_avg={format_num(per_session_bw['avg'])} "
+        f"per_session_p95={format_num(per_session_bw['p95'])} "
+        f"global={format_num(bandwidth['global_goodput_mbps'])} "
+        f"bucket_avg={format_num(bucket_bw['avg_mbps'])} "
+        f"bucket_peak={format_num(bucket_bw['peak_mbps'])}"
+    )
     print(f"VERDICT: {'PASS' if summary['passed'] else 'FAIL'}")
     if summary["fail_reasons"]:
         print("Fail reasons:")
@@ -588,8 +670,10 @@ def distribute_sessions(total_clients: int, process_count: int) -> list[int]:
 
 def run_stress(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
     if websockets is None:
-        raise RuntimeError("Missing dependency: websockets. Install it before running this "
-                           "stress test.")
+        raise RuntimeError(
+            "Missing dependency: websockets. Install it before running this "
+            "stress test."
+        )
 
     preset_file = Path(args.preset_file).expanduser().resolve()
     selected_preset_id, curated_prompts, total_prompt_count = load_curated_prompts(
@@ -651,8 +735,13 @@ def run_stress(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
 
         start_event.set()
 
-        result_deadline = (time.monotonic() + args.connect_timeout_s + args.session_timeout_s +
-                           args.post_complete_wait_s + 180.0)
+        result_deadline = (
+            time.monotonic()
+            + args.connect_timeout_s
+            + args.session_timeout_s
+            + args.post_complete_wait_s
+            + 180.0
+        )
         worker_results: list[dict[str, Any]] = []
         while len(worker_results) < len(processes):
             timeout_s = max(0.1, result_deadline - time.monotonic())
@@ -676,20 +765,24 @@ def run_stress(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
             if result.get("status") == "ok":
                 sessions.extend(result.get("sessions", []))
             else:
-                worker_errors.append({
-                    "worker_id": result.get("worker_id"),
-                    "error": result.get("error"),
-                    "traceback": result.get("traceback"),
-                })
+                worker_errors.append(
+                    {
+                        "worker_id": result.get("worker_id"),
+                        "error": result.get("error"),
+                        "traceback": result.get("traceback"),
+                    }
+                )
 
         received_workers = {result.get("worker_id") for result in worker_results}
         expected_workers = set(range(len(processes)))
         missing_workers = sorted(expected_workers - received_workers)
         for worker_id in missing_workers:
-            worker_errors.append({
-                "worker_id": worker_id,
-                "error": "No worker result received.",
-            })
+            worker_errors.append(
+                {
+                    "worker_id": worker_id,
+                    "error": "No worker result received.",
+                }
+            )
 
         run_end_epoch = time.time()
         run_end_iso = iso_from_epoch(run_end_epoch)
@@ -702,8 +795,9 @@ def run_stress(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
 
         if worker_errors:
             summary["passed"] = False
-            summary["fail_reasons"] = list(
-                summary["fail_reasons"]) + [f"{len(worker_errors)} worker error(s) occurred."]
+            summary["fail_reasons"] = list(summary["fail_reasons"]) + [
+                f"{len(worker_errors)} worker error(s) occurred."
+            ]
 
         output_payload = {
             "run_info": {
@@ -739,7 +833,9 @@ def run_stress(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
 
 
 def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Multiprocess realtime stress test for LTX2 streaming.", )
+    parser = argparse.ArgumentParser(
+        description="Multiprocess realtime stress test for LTX2 streaming.",
+    )
     parser.add_argument(
         "-u",
         "--url",

apps/dreamverse/dreamverse/tests/test_session_init_image.py

@@ -47,11 +47,13 @@ def test_persist_session_init_image_returns_none_when_missing_data():
 
 def test_persist_session_init_image_rejects_unsupported_mime():
     with pytest.raises(ValueError, match="PNG, JPEG, or WebP"):
-        persist_session_init_image({
-            "name": "frame.gif",
-            "mime_type": "image/gif",
-            "data_url": "data:image/gif;base64,R0lGODlhAQABAAAAACw=",
-        })
+        persist_session_init_image(
+            {
+                "name": "frame.gif",
+                "mime_type": "image/gif",
+                "data_url": "data:image/gif;base64,R0lGODlhAQABAAAAACw=",
+            }
+        )
 
 
 def test_persist_session_init_image_rejects_large_payload(monkeypatch):
@@ -64,8 +66,10 @@ def test_persist_session_init_image_rejects_large_payload(monkeypatch):
     monkeypatch.setattr(base64, "b64decode", fake_b64decode)
 
     with pytest.raises(ValueError, match="15 MB or smaller"):
-        persist_session_init_image({
-            "name": "frame.png",
-            "mime_type": "image/png",
-            "data_url": data_url,
-        })
+        persist_session_init_image(
+            {
+                "name": "frame.png",
+                "mime_type": "image/png",
+                "data_url": data_url,
+            }
+        )

apps/dreamverse/scripts/modal/modal_app.py

@@ -8,10 +8,12 @@ import modal
 
 IMAGE = os.environ.get("DREAMVERSE_IMAGE")
 if not IMAGE:
-    raise RuntimeError("DREAMVERSE_IMAGE is required. Set it to a published SHA-specific Dreamverse image, "
-                       "for example a dreamverse-backend-cuda13.0.0-sha-* tag or a "
-                       "dreamverse-ui-cuda13.0.0-sha-* tag if serving the static UI. "
-                       "CUDA 12 / cu126 images use the corresponding cuda12.6.3 tag.")
+    raise RuntimeError(
+        "DREAMVERSE_IMAGE is required. Set it to a published SHA-specific Dreamverse image, "
+        "for example a dreamverse-backend-cuda13.0.0-sha-* tag or a "
+        "dreamverse-ui-cuda13.0.0-sha-* tag if serving the static UI. "
+        "CUDA 12 / cu126 images use the corresponding cuda12.6.3 tag."
+    )
 
 # ``@modal.web_server`` invokes ``serve()`` directly and bypasses the image
 # ENTRYPOINT (``docker/docker_entrypoint.sh``).  That entrypoint normally
@@ -63,10 +65,14 @@ def serve():
     # ``or ""`` collapses ``None`` (unset) into an empty string, ``.strip()``
     # collapses whitespace-only values (e.g. ``"   "``) — both should be
     # treated as missing.
-    missing = [k for k in _REQUIRED_SECRET_KEYS if not (os.environ.get(k) or "").strip()]
+    missing = [
+        k for k in _REQUIRED_SECRET_KEYS
+        if not (os.environ.get(k) or "").strip()
+    ]
     if missing:
-        raise RuntimeError("dreamverse-api-keys secret is missing required entries: "
-                           f"{', '.join(missing)}. Add them with `modal secret create "
-                           "dreamverse-api-keys ... --force` and redeploy "
-                           "(see apps/dreamverse/scripts/modal/README.md).")
+        raise RuntimeError(
+            "dreamverse-api-keys secret is missing required entries: "
+            f"{', '.join(missing)}. Add them with `modal secret create "
+            "dreamverse-api-keys ... --force` and redeploy "
+            "(see apps/dreamverse/scripts/modal/README.md).")
     subprocess.Popen(["dreamverse-server", "--host", "0.0.0.0", "--port", "8009"])

apps/fastvideo_studio/e2e/generators.spec.ts

@@ -0,0 +1,39 @@
+import { expect, test } from '@playwright/test';
+
+import { skipWithoutMock } from './helpers';
+
+/**
+ * Warm-model slot: load a model through the mock (which flips
+ * loading -> ready after ~2s, surfaced by the panel's 5s poll), then unload it.
+ */
+test.describe('generators', () => {
+  skipWithoutMock();
+
+  test('loads and unloads the resident model', async ({ page }) => {
+    await page.goto('/inference');
+
+    const panel = page.getByRole('region', { name: 'Warm models' });
+    await expect(panel).toBeVisible();
+    await expect(panel.getByText('No model loaded')).toBeVisible();
+
+    await panel
+      .getByLabel('Model to load')
+      .selectOption('Wan-AI/Wan2.1-T2V-1.3B-Diffusers');
+    await panel.getByRole('button', { name: 'Load model' }).click();
+
+    await expect(panel.getByText('Wan2.1 T2V 1.3B Diffusers')).toBeVisible();
+    await expect(panel.getByText('ready')).toBeVisible();
+
+    await panel.getByRole('button', { name: 'Unload' }).click();
+    await expect(panel.getByText('No model loaded')).toBeVisible();
+  });
+
+  test('engine console streams output while open', async ({ page }) => {
+    await page.goto('/inference');
+
+    const engineConsole = page.getByRole('region', { name: 'Engine output' });
+    await engineConsole.getByRole('button', { name: 'Engine output' }).click();
+
+    await expect(engineConsole.getByText(/\[engine\]/).first()).toBeVisible();
+  });
+});

apps/fastvideo_studio/gpu.py

@@ -72,3 +72,90 @@ def get_gpu_snapshot() -> dict[str, Any]:
     except Exception as exc:  # NVMLError, driver issues, …
         logger.warning("GPU snapshot failed: %s", exc)
         return {"available": False, "gpus": [], "error": str(exc)}
+
+
+def _remote_gpu_probe() -> dict[str, Any]:
+    """Self-contained per-node NVML probe (runs as a ray task on each node;
+    no fastvideo_studio import — worker environments don't have apps/ on
+    their path, so cloudpickle must carry this by value)."""
+    import contextlib as _ctx
+    import socket as _socket
+    out: dict[str, Any] = {"hostname": _socket.gethostname(), "available": False, "gpus": [], "error": None}
+    try:
+        import pynvml
+        pynvml.nvmlInit()
+        for i in range(pynvml.nvmlDeviceGetCount()):
+            h = pynvml.nvmlDeviceGetHandleByIndex(i)
+            name = pynvml.nvmlDeviceGetName(h)
+            if isinstance(name, bytes):
+                name = name.decode()
+            mem = pynvml.nvmlDeviceGetMemoryInfo(h)
+            util = pynvml.nvmlDeviceGetUtilizationRates(h)
+            temp = power = plimit = None
+            with _ctx.suppress(pynvml.NVMLError):
+                temp = int(pynvml.nvmlDeviceGetTemperature(h, pynvml.NVML_TEMPERATURE_GPU))
+            with _ctx.suppress(pynvml.NVMLError):
+                power = pynvml.nvmlDeviceGetPowerUsage(h) / 1000.0
+                plimit = pynvml.nvmlDeviceGetEnforcedPowerLimit(h) / 1000.0
+            out["gpus"].append({
+                "index": i,
+                "name": name,
+                "utilization": int(util.gpu),
+                "memory_used_mib": int(mem.used / (1024 * 1024)),
+                "memory_total_mib": int(mem.total / (1024 * 1024)),
+                "temperature_c": temp,
+                "power_watts": power,
+                "power_limit_watts": plimit,
+            })
+        out["available"] = True
+    except Exception as exc:  # noqa: BLE001 -- reported per node
+        out["error"] = str(exc)
+    return out
+
+
+def get_cluster_snapshot() -> dict[str, Any]:
+    """Cluster-wide GPU/host telemetry.
+
+    When this process is connected to a ray cluster (a model has been
+    loaded), probe every alive node via per-node ray tasks. Otherwise fall
+    back to this host's NVML snapshot. Never raises.
+    """
+    import socket
+
+    local = get_gpu_snapshot()
+    local_node = {"hostname": socket.gethostname(), "ip": None, "is_this_host": True,
+                  "cpus": None, "ray_gpus": None, **local}
+    out: dict[str, Any] = {"mode": "local", "nodes": [local_node],
+                           "resources": None, "error": None}
+    try:
+        import ray
+        if not ray.is_initialized():
+            out["error"] = "not connected to a ray cluster yet (load a model first); showing the API host only"
+            return out
+        from ray.util.scheduling_strategies import NodeAffinitySchedulingStrategy
+        alive = [n for n in ray.nodes() if n.get("Alive")]
+        probe = ray.remote(num_cpus=0)(_remote_gpu_probe)
+        refs = [probe.options(scheduling_strategy=NodeAffinitySchedulingStrategy(
+            node_id=n["NodeID"], soft=True)).remote() for n in alive]
+        snaps = ray.get(refs, timeout=15)
+        nodes = []
+        for n, snap in zip(alive, snaps, strict=True):
+            nodes.append({
+                "ip": n.get("NodeManagerAddress"),
+                "is_this_host": snap.get("hostname") == socket.gethostname(),
+                "cpus": n.get("Resources", {}).get("CPU"),
+                "ray_gpus": n.get("Resources", {}).get("GPU"),
+                **snap,
+            })
+        out["mode"] = "ray"
+        out["nodes"] = nodes
+        out["resources"] = {
+            "gpus_total": ray.cluster_resources().get("GPU", 0.0),
+            "gpus_available": ray.available_resources().get("GPU", 0.0),
+        }
+    except Exception as exc:  # noqa: BLE001 -- degrade to the local view
+        logger.warning("cluster snapshot failed: %s", exc)
+        out["mode"] = "local"
+        out["nodes"] = [local_node]
+        out["error"] = f"cluster probe failed: {exc}"
+    return out

apps/fastvideo_studio/job_runner.py

@@ -41,6 +41,11 @@ _TQDM_FRAC_RE = re.compile(r"\b(\d+)/(\d+)\b")
 
 _MAX_LOG_LINES = 2000  # ring-buffer cap per job
 
+# ray's log relay prefixes worker lines like "(RayWorkerWrapper pid=123, ip=…)"
+# — usually wrapped in ANSI color codes, which must be stripped before matching.
+_RAY_RELAY_RE = re.compile(r"^\(\w+ pid=")
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
 
 class JobStatus(str, enum.Enum):
     PENDING = "pending"
@@ -259,13 +264,36 @@ class JobRunner:
         self._jobs_lock = threading.Lock()
         self._load_jobs()
 
-        # Cache of loaded generators keyed by model config so that we only pay
-        # the model-loading cost once per model configuration.
-        self._generators: dict[tuple, Any] = {}
-        self._generators_lock = threading.Lock()
+        # Exactly one generator lives in memory at a time. Loading a new
+        # config always releases the old instance first (shutdown + placement
+        # group teardown); unload deletes it outright.
+        self._generator: Any | None = None
+        self._generator_config: dict[str, Any] | None = None
+        self._generator_state: str = "empty"  # empty | loading | ready | failed
+        self._generator_error: str | None = None
+        self._generator_lock = threading.Lock()  # guards the fields above
+        # Serializes every slot transition (preload, job-triggered replace,
+        # unload). Held for the full duration of a load.
+        self._load_lock = threading.Lock()
+        # All generator creations run on this ONE persistent thread: the mp
+        # executor arms prctl(PR_SET_PDEATHSIG, SIGKILL) in its workers, and
+        # on Linux that fires when the CREATING THREAD exits — a generator
+        # spawned from a short-lived thread loses all its workers (silent
+        # SIGKILL, zombies) the moment that thread finishes.
+        import queue as _queue
+        self._loader_queue: _queue.Queue = _queue.Queue()
+        threading.Thread(target=self._loader_loop, daemon=True,
+                         name="generator-loader").start()
+        # The inference job currently generating, fed by the engine log tee
+        # (ray relays worker output to the driver; tqdm lines land there).
+        self._active_inference_job: Job | None = None
 
         # Shared Manager for log queues (avoids spawning a new process per job)
         self._mp_manager = get_mp_context().Manager()
+        # One queue for the generator's whole life: mp workers get it at spawn
+        # (creation-time attach). Sending a Manager proxy over the executor's
+        # worker pipes post-hoc (set_log_queue RPC) breaks the pipe.
+        self._worker_log_queue = self._mp_manager.Queue()
         atexit.register(self._shutdown)
 
         # Ensure directories exist
@@ -617,6 +645,211 @@ class JobRunner:
             "phase": job._log_buf.phase,
         }
 
+    @staticmethod
+    def _generator_config_dict(
+        model_id: str,
+        workload_type: str,
+        num_gpus: int,
+        dit_cpu_offload: bool = False,
+        text_encoder_cpu_offload: bool = False,
+        vae_cpu_offload: bool = False,
+        image_encoder_cpu_offload: bool = False,
+        use_fsdp_inference: bool = False,
+        enable_torch_compile: bool = False,
+        vsa_sparsity: float = 0.0,
+        tp_size: int = -1,
+        sp_size: int = -1,
+    ) -> dict[str, Any]:
+        """Canonical engine-config dict; equality here == same generator."""
+        return {
+            "model_id": model_id,
+            "workload_type": workload_type,
+            "num_gpus": num_gpus,
+            "dit_cpu_offload": dit_cpu_offload,
+            "text_encoder_cpu_offload": text_encoder_cpu_offload,
+            "vae_cpu_offload": vae_cpu_offload,
+            "image_encoder_cpu_offload": image_encoder_cpu_offload,
+            "use_fsdp_inference": use_fsdp_inference,
+            "enable_torch_compile": enable_torch_compile,
+            "vsa_sparsity": vsa_sparsity,
+            "tp_size": tp_size,
+            "sp_size": sp_size,
+        }
+
+    def _slot_entry(self) -> dict[str, Any]:
+        return {
+            "state": self._generator_state,
+            "error": self._generator_error,
+            **(self._generator_config or {}),
+        }
+
+    def _running_inference_jobs(self) -> list[str]:
+        with self._jobs_lock:
+            return [j.id for j in self._jobs.values()
+                    if j.status == JobStatus.RUNNING and j.job_type == "inference"]
+
+    def _loader_loop(self) -> None:
+        while True:
+            fn = self._loader_queue.get()
+            try:
+                fn()
+            except BaseException:  # noqa: BLE001 -- surfaced via the caller's box
+                pass
+            finally:
+                self._loader_queue.task_done()
+
+    def _run_on_loader(self, fn: Any) -> Any:
+        """Run ``fn`` on the persistent loader thread and return its result."""
+        box: dict[str, Any] = {}
+        done = threading.Event()
+
+        def wrapped() -> None:
+            try:
+                box["r"] = fn()
+            except BaseException as exc:  # noqa: BLE001 -- re-raised below
+                box["e"] = exc
+            finally:
+                done.set()
+
+        self._loader_queue.put(wrapped)
+        done.wait()
+        if "e" in box:
+            raise box["e"]
+        return box["r"]
+
+    def preload_generator(self, **params: Any) -> dict[str, Any]:
+        """Load a model into memory ahead of time. One load at a time; loading
+        a different config always releases the current instance first."""
+        config = self._generator_config_dict(**params)
+        with self._generator_lock:
+            if self._generator_state == "ready" and self._generator_config == config:
+                return self._slot_entry()
+        if not self._load_lock.acquire(blocking=False):
+            raise RuntimeError("a model load is already in progress")
+        try:
+            if self._running_inference_jobs():
+                raise RuntimeError("cannot swap models while inference jobs are running")
+            with self._generator_lock:
+                self._generator_state = "loading"
+                self._generator_config = config
+                self._generator_error = None
+                entry = self._slot_entry()
+        except BaseException:
+            self._load_lock.release()
+            raise
+
+        def _load() -> None:
+            try:  # the preload owns _load_lock until the load resolves
+                self._run_on_loader(lambda: self._load_into_slot_locked(config))
+            except Exception:  # noqa: BLE001 -- state already set to failed
+                pass
+            finally:
+                self._load_lock.release()
+
+        threading.Thread(target=_load, daemon=True, name="generator-preload").start()
+        return entry
+
+    def _load_into_slot_locked(self, config: dict[str, Any]) -> Any:
+        """Release whatever is resident and load ``config``. Caller MUST hold
+        ``_load_lock``. State is 'loading' on entry or set here."""
+        with self._generator_lock:
+            gen = self._generator
+            self._generator = None
+            self._generator_state = "loading"
+            self._generator_config = config
+            self._generator_error = None
+        if gen is not None:
+            logger.info("Releasing resident generator before loading a new one")
+            gen.shutdown()
+            del gen
+
+        # Import lazily so starting the server is fast even without a GPU.
+        from fastvideo import VideoGenerator
+
+        # Deployment-level knobs (set where the API server is launched):
+        # FASTVIDEO_STUDIO_MODEL_PATHS="id=/local/dir,..." serves a registered
+        # model id from local weights instead of the HF hub;
+        # FASTVIDEO_STUDIO_EXECUTOR_BACKEND=ray runs workers on an existing
+        # Ray cluster (the multi-node path — "mp" spawns local processes only).
+        model_path = config["model_id"]
+        for pair in os.environ.get("FASTVIDEO_STUDIO_MODEL_PATHS", "").split(","):
+            mid, sep, path = pair.partition("=")
+            if sep and mid.strip() == config["model_id"]:
+                model_path = path.strip()
+        executor_kwargs: dict[str, Any] = {}
+        backend = os.environ.get("FASTVIDEO_STUDIO_EXECUTOR_BACKEND")
+        if backend:
+            executor_kwargs["distributed_executor_backend"] = backend
+
+        logger.info("Loading model %s (%s)", config["model_id"],
+                    ", ".join(f"{k}={v}" for k, v in config.items() if k != "model_id"))
+        try:
+            new_gen = VideoGenerator.from_pretrained(
+                model_path,
+                workload_type=config["workload_type"],
+                num_gpus=config["num_gpus"],
+                dit_cpu_offload=config["dit_cpu_offload"],
+                # FastVideoArgs defaults this True, which disables FSDP and
+                # parks a full DiT copy in host RAM per worker — the mp
+                # executor's 4 workers OOM-killed the node silently. The UI's
+                # offload toggles are the studio's contract; layerwise off.
+                dit_layerwise_offload=False,
+                text_encoder_cpu_offload=config["text_encoder_cpu_offload"],
+                vae_cpu_offload=config["vae_cpu_offload"],
+                image_encoder_cpu_offload=config["image_encoder_cpu_offload"],
+                use_fsdp_inference=config["use_fsdp_inference"],
+                enable_torch_compile=config["enable_torch_compile"],
+                VSA_sparsity=config["vsa_sparsity"],
+                tp_size=config["tp_size"],
+                sp_size=config["sp_size"],
+                log_queue=self._worker_log_queue,
+                **executor_kwargs,
+            )
+        except Exception as exc:
+            logger.exception("Model load failed for %s", config["model_id"])
+            with self._generator_lock:
+                self._generator_state = "failed"
+                self._generator_error = str(exc)
+            raise
+        with self._generator_lock:
+            self._generator = new_gen
+            self._generator_config = config
+            self._generator_state = "ready"
+            self._generator_error = None
+        return new_gen
+
+    def list_generators(self) -> list[dict[str, Any]]:
+        """The resident slot, or empty when nothing is loaded."""
+        with self._generator_lock:
+            if self._generator_state == "empty":
+                return []
+            return [self._slot_entry()]
+
+    def unload_generator(self, **_ignored: Any) -> bool:
+        """Shut down and delete the resident generator, freeing GPU memory."""
+        if not self._load_lock.acquire(blocking=False):
+            raise RuntimeError("cannot unload while a model load is in progress")
+        try:
+            running = self._running_inference_jobs()
+            if running:
+                raise RuntimeError(f"cannot unload while inference jobs are running: {running}")
+            with self._generator_lock:
+                gen = self._generator
+                empty = self._generator_state == "empty"
+                self._generator = None
+                self._generator_state = "empty"
+                self._generator_config = None
+                self._generator_error = None
+            if empty:
+                return False
+            if gen is not None:
+                logger.info("Releasing resident generator")
+                gen.shutdown()
+                del gen
+            return True
+        finally:
+            self._load_lock.release()
+
     def _get_or_create_generator(
         self,
         model_id: str,
@@ -633,69 +866,53 @@ class JobRunner:
         sp_size: int = -1,
         log_queue: mp.Queue | None = None,
     ) -> Any:
-        cache_key = (
-            model_id,
-            workload_type,
-            num_gpus,
-            dit_cpu_offload,
-            text_encoder_cpu_offload,
-            vae_cpu_offload,
-            image_encoder_cpu_offload,
-            use_fsdp_inference,
-            enable_torch_compile,
-            vsa_sparsity,
-            tp_size,
-            sp_size,
-        )
-
-        # Generators are cached by model_id and configuration parameters
-        with self._generators_lock:
-            if cache_key in self._generators:
-                return self._generators[cache_key]
-
-        # Import lazily so starting the server is fast even without a GPU.
-        from fastvideo import VideoGenerator
-
-        logger.info(
-            "Loading model %s (workload=%s, num_gpus=%d, offloads: "
-            "dit=%s text_encoder=%s vae=%s image_encoder=%s, fsdp=%s, "
-            "torch_compile=%s, vsa_sparsity=%.2f, tp=%d sp=%d) …",
-            model_id,
-            workload_type,
-            num_gpus,
-            dit_cpu_offload,
-            text_encoder_cpu_offload,
-            vae_cpu_offload,
-            image_encoder_cpu_offload,
-            use_fsdp_inference,
-            enable_torch_compile,
-            vsa_sparsity,
-            tp_size,
-            sp_size,
-        )
-
-        gen = VideoGenerator.from_pretrained(
-            model_id,
+        """Return the resident generator if the config matches; otherwise
+        replace the slot. Blocks behind any in-flight load — every slot
+        transition happens under ``_load_lock``, so a job can never observe a
+        half-replaced slot."""
+        del log_queue  # single-slot generators log via the engine tee
+        config = self._generator_config_dict(
+            model_id=model_id,
             workload_type=workload_type,
+            num_gpus=num_gpus,
             dit_cpu_offload=dit_cpu_offload,
             text_encoder_cpu_offload=text_encoder_cpu_offload,
             vae_cpu_offload=vae_cpu_offload,
             image_encoder_cpu_offload=image_encoder_cpu_offload,
             use_fsdp_inference=use_fsdp_inference,
             enable_torch_compile=enable_torch_compile,
-            VSA_sparsity=vsa_sparsity,
+            vsa_sparsity=vsa_sparsity,
             tp_size=tp_size,
             sp_size=sp_size,
-            log_queue=log_queue,
         )
+        with self._load_lock:  # waits out preloads / other jobs' replaces
+            with self._generator_lock:
+                if (self._generator_state == "ready"
+                        and self._generator_config == config
+                        and self._generator is not None):
+                    return self._generator
+            return self._run_on_loader(lambda: self._load_into_slot_locked(config))
 
-        with self._generators_lock:
-            if cache_key not in self._generators:
-                self._generators[cache_key] = gen
-            else:  # Another thread may have created it while we were loading.
-                gen.shutdown()
-                gen = self._generators[cache_key]
-        return gen
+    def feed_engine_line(self, line: str) -> None:
+        """Bridge ray-relayed worker output into the running job's log buffer.
+
+        On the ray backend worker logs cannot cross nodes via the mp queue,
+        but ray already relays them to the driver's stdout — which the engine
+        tee captures. Lines with ray's actor prefix are attributed to the one
+        running inference job, whose buffer parses tqdm into UI progress.
+        Driver-side logging is excluded (it reaches the buffer via the
+        logging handlers already).
+        """
+        job = self._active_inference_job
+        if job is None:
+            return
+        line = _ANSI_RE.sub("", line)
+        if not _RAY_RELAY_RE.match(line):
+            return
+        try:
+            job._log_buf.write(line)
+        except Exception:  # noqa: BLE001 -- never break the tee
+            pass
 
     def _run_job(self, job: Job):
         if job.job_type == "inference":
@@ -841,10 +1058,12 @@ class JobRunner:
         fastvideo_logger.addHandler(buffer_handler)
         fastvideo_logger.addHandler(file_handler)
 
-        # Queue for worker process logs (fsdp_load, cuda, etc.)
-        # Use Manager().Queue() so it can be shared with spawned workers (spawn
-        # does not inherit memory; mp.Queue only works through inheritance).
-        log_queue = self._mp_manager.Queue()
+        # Worker logs flow through the runner-wide queue the generator was
+        # created with; drain anything stale, then listen for this job.
+        log_queue = self._worker_log_queue
+        with contextlib.suppress(Exception):
+            while True:
+                log_queue.get_nowait()
         queue_listener = logging.handlers.QueueListener(log_queue,
                                                         buffer_handler,
                                                         file_handler,
@@ -926,6 +1145,7 @@ class JobRunner:
 
             generator = _gen_result[0]
             buf.phase = "generating"
+            self._active_inference_job = job  # engine tee feeds tqdm from here
             logger.info("Starting generation for job %s (model=%s)", job.id, job.model_id)
 
             gen_kwargs: dict[str, Any] = {
@@ -941,7 +1161,6 @@ class JobRunner:
                 "fps": job.fps,
                 "seed": job.seed,
                 "negative_prompt": job.negative_prompt or "",
-                "log_queue": log_queue,
             }
             if job.image_path:
                 gen_kwargs["image_path"] = job.image_path
@@ -985,6 +1204,8 @@ class JobRunner:
             buf.phase = "failed"
 
         finally:
+            if self._active_inference_job is job:
+                self._active_inference_job = None
             queue_listener.stop()
             # Remove handlers and close file
             fastvideo_logger.removeHandler(buffer_handler)

apps/fastvideo_studio/mock_server.py

@@ -36,13 +36,15 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, PlainTextResponse
 
 from fastvideo_studio.database import default_settings_dict
-from fastvideo_studio.models import (CreateDatasetRequest, CreateJobRequest, SettingsUpdate, UpdateCaptionRequest,
-                                     model_label)
+from fastvideo_studio.models import (CreateDatasetRequest, CreateJobRequest, GeneratorRequest, SettingsUpdate,
+                                     UpdateCaptionRequest, model_label)
 
 # --- Config -----------------------------------------------------------------
 
 # How long a started job stays "running" before it flips to "completed".
 COMPLETE_AFTER_SECONDS = 3.0
+# How long a preloading generator stays "loading" before it flips to "ready".
+GENERATOR_READY_AFTER_SECONDS = 2.0
 FFMPEG_BIN = shutil.which(os.getenv("FASTVIDEO_FFMPEG_BIN", "ffmpeg"))
 
 # A small catalogue of fake models keyed by workload type. Mirrors the real
@@ -88,6 +90,10 @@ _DEFAULT_SETTINGS: dict[str, Any] = {
 _state_lock = threading.Lock()
 _settings: dict[str, Any] = dict(_DEFAULT_SETTINGS)
 _jobs: dict[str, dict[str, Any]] = {}
+# The engine's single model slot: None when empty, else the state dict.
+_generator_slot: dict[str, Any] | None = None
+# Fake engine stdout/stderr tail; grows a little on every poll.
+_engine_log_lines: list[str] = ["[engine] FastVideo studio mock engine started"]
 _datasets: dict[str, dict[str, Any]] = {}
 # dataset_id -> {"file_names": [...], "captions": {file_name: caption}}
 _dataset_files: dict[str, dict[str, Any]] = {}
@@ -393,6 +399,56 @@ def list_models(workload_type: str | None = None) -> list[dict[str, Any]]:
     return _models_for(workload_type)
 
 
+# Per-model sampling presets, mirroring the real /api/models/presets shape
+# (keys the model has no recommendation for are simply absent).
+_MODEL_PRESETS: dict[str, dict[str, Any]] = {
+    "Wan-AI/Wan2.1-T2V-1.3B-Diffusers": {
+        "height": 480,
+        "width": 832,
+        "num_frames": 81,
+        "fps": 16,
+        "num_inference_steps": 50,
+        "guidance_scale": 3.0,
+        "guidance_rescale": 0.0,
+        "negative_prompt": "Bright tones, overexposed, static, blurred details",
+        "seed": 1024,
+    },
+    "Wan-AI/Wan2.1-I2V-14B-480P-Diffusers": {
+        "height": 480,
+        "width": 832,
+        "num_frames": 81,
+        "fps": 16,
+        "num_inference_steps": 40,
+        "guidance_scale": 5.0,
+        "seed": 1024,
+    },
+    "black-forest-labs/FLUX.1-schnell": {
+        "height": 1024,
+        "width": 1024,
+        "num_frames": 1,
+        "num_inference_steps": 4,
+        "guidance_scale": 0.0,
+        "seed": 42,
+    },
+}
+_GENERIC_PRESETS: dict[str, Any] = {
+    "height": 720,
+    "width": 1280,
+    "num_frames": 81,
+    "fps": 24,
+    "num_inference_steps": 50,
+    "guidance_scale": 5.0,
+    "guidance_rescale": 0.0,
+    "seed": 1024,
+}
+
+
+@app.get("/api/models/presets")
+def model_presets(model_id: str) -> dict[str, Any]:
+    """Recommended sampling settings; unknown models get generic defaults."""
+    return _MODEL_PRESETS.get(model_id, _GENERIC_PRESETS)
+
+
 # --- GPUs -------------------------------------------------------------------
 
 
@@ -414,6 +470,49 @@ def list_gpus() -> dict[str, Any]:
     return {"available": True, "gpus": gpus, "error": None}
 
 
+@app.get("/api/cluster")
+def cluster_status() -> dict[str, Any]:
+    """Two fake ray nodes x 4 GPUs with per-request jitter, mirroring the
+    real server's /api/cluster shape."""
+    nodes = []
+    for host_idx, (hostname, ip, is_this_host) in enumerate([
+        ("mock-node-0", "10.0.0.10", True),
+        ("mock-node-1", "10.0.0.11", False),
+    ]):
+        gpus = []
+        for index in range(4):
+            base_util = (13 + 29 * index + 41 * host_idx) % 100
+            gpus.append({
+                "index": index,
+                "name": "NVIDIA Mock GPU 80GB",
+                "utilization": max(0, min(100, base_util + random.randint(-5, 5))),
+                "memory_used_mib": 6_144 + 17_408 * index + random.randint(-256, 256),
+                "memory_total_mib": 81_920,
+                "temperature_c": 42 + 6 * index + random.randint(-3, 3),
+                "power_watts": 110.0 + 140.0 * index + random.randint(-20, 20),
+                "power_limit_watts": 700.0,
+            })
+        nodes.append({
+            "hostname": hostname,
+            "ip": ip,
+            "is_this_host": is_this_host,
+            "cpus": 64.0,
+            "ray_gpus": 4.0,
+            "available": True,
+            "error": None,
+            "gpus": gpus,
+        })
+    return {
+        "mode": "ray",
+        "nodes": nodes,
+        "resources": {
+            "gpus_total": 8.0,
+            "gpus_available": 5.0
+        },
+        "error": None,
+    }
+
+
 # --- Uploads ----------------------------------------------------------------
 
 
@@ -570,6 +669,92 @@ def download_log(job_id: str) -> PlainTextResponse:
     return PlainTextResponse("\n".join(lines) + "\n", media_type="text/plain")
 
 
+# --- Generators (warm models) -------------------------------------------------
+
+
+def _advance_generator(entry: dict[str, Any]) -> None:
+    """Flip a loading generator to ready once enough wall-clock time has passed.
+
+    Like job status, generator state is *computed on read*, so polling the
+    generators list naturally shows loading -> ready.
+    """
+    if entry["state"] == "loading" and time.time() - entry["started_at"] >= GENERATOR_READY_AFTER_SECONDS:
+        entry["state"] = "ready"
+
+
+def _running_inference_ids() -> list[str]:
+    return [
+        j["id"] for j in _jobs.values() if j.get("job_type") == "inference" and _public_job(j)["status"] == "running"
+    ]
+
+
+@app.get("/api/generators")
+def list_generators() -> list[dict[str, Any]]:
+    with _state_lock:
+        if _generator_slot is None:
+            return []
+        _advance_generator(_generator_slot)
+        return [dict(_generator_slot)]
+
+
+@app.post("/api/generators/preload", status_code=202)
+def preload_generator(req: GeneratorRequest) -> dict[str, Any]:
+    global _generator_slot
+    valid_ids = {m["id"] for m in _models_for(None)}
+    if req.model_id not in valid_ids:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unknown model_id '{req.model_id}'. Valid options: {sorted(valid_ids)}",
+        )
+    with _state_lock:
+        if _generator_slot is not None:
+            _advance_generator(_generator_slot)
+            if _generator_slot["state"] == "loading":
+                raise HTTPException(status_code=409, detail="a model load is already in progress")
+            if _generator_slot["state"] == "ready" and all(
+                    _generator_slot.get(k) == v for k, v in req.model_dump().items()):
+                return dict(_generator_slot)
+        running = _running_inference_ids()
+        if running:
+            raise HTTPException(status_code=409,
+                                detail=f"cannot swap models while inference jobs are running: {running}")
+        # Loading a new model always replaces (releases) the resident one.
+        _generator_slot = {"state": "loading", "started_at": time.time(), "error": None, **req.model_dump()}
+        return dict(_generator_slot)
+
+
+@app.post("/api/generators/unload")
+def unload_generator() -> dict[str, Any]:
+    global _generator_slot
+    with _state_lock:
+        if _generator_slot is not None:
+            _advance_generator(_generator_slot)
+            if _generator_slot["state"] == "loading":
+                raise HTTPException(status_code=409, detail="cannot unload while a model load is in progress")
+        if _generator_slot is None:
+            raise HTTPException(status_code=404, detail="No model is loaded")
+        running = _running_inference_ids()
+        if running:
+            raise HTTPException(status_code=409, detail=f"cannot unload while inference jobs are running: {running}")
+        _generator_slot = None
+    return {"unloaded": True}
+
+
+# --- Engine logs --------------------------------------------------------------
+
+
+@app.get("/api/engine/logs")
+def engine_logs(after: int = 0) -> dict[str, Any]:
+    """Growing fake tail of the engine's stdout/stderr: every poll appends a
+    couple of lines so the console visibly streams."""
+    with _state_lock:
+        n = len(_engine_log_lines)
+        _engine_log_lines.append(f"[engine] step {n}: worker heartbeat ok")
+        _engine_log_lines.append(f"[engine] step {n + 1}: gpu mem {random.randint(20, 80)}% used")
+        total = len(_engine_log_lines)
+        return {"lines": _engine_log_lines[max(0, after):], "total": total}
+
+
 # --- Datasets ---------------------------------------------------------------
 
 

apps/fastvideo_studio/models/__init__.py

@@ -3,6 +3,7 @@
 usable by both the real server and the dependency-light mock server."""
 
 from fastvideo_studio.models.create_job_request import CreateJobRequest
+from fastvideo_studio.models.generator_request import GeneratorRequest
 from fastvideo_studio.models.settings_update import SettingsUpdate
 from fastvideo_studio.models.create_dataset_request import CreateDatasetRequest
 from fastvideo_studio.models.update_caption_request import UpdateCaptionRequest
@@ -15,6 +16,7 @@ def model_label(model_path: str) -> str:
 
 __all__ = [
     "CreateJobRequest",
+    "GeneratorRequest",
     "SettingsUpdate",
     "CreateDatasetRequest",
     "UpdateCaptionRequest",

apps/fastvideo_studio/models/generator_request.py

@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Request model for preloading/unloading a resident generator.
+
+Field names and defaults mirror the engine subset of ``CreateJobRequest`` so
+the UI can send exactly the values it would put on a job — guaranteeing the
+job's generator lookup hits this cache entry.
+"""
+
+from pydantic import BaseModel
+
+
+class GeneratorRequest(BaseModel):
+    model_id: str
+    workload_type: str = "t2v"
+    num_gpus: int = 1
+    dit_cpu_offload: bool = False
+    text_encoder_cpu_offload: bool = False
+    vae_cpu_offload: bool = False
+    image_encoder_cpu_offload: bool = False
+    use_fsdp_inference: bool = False
+    enable_torch_compile: bool = False
+    vsa_sparsity: float = 0.0
+    tp_size: int = -1
+    sp_size: int = -1

apps/fastvideo_studio/server.py

@@ -32,10 +32,10 @@ from fastapi.responses import FileResponse
 
 from fastvideo.registry import (get_registered_model_paths, get_registered_models_with_workloads)
 from fastvideo_studio.database import Database, _get_db_path
-from fastvideo_studio.gpu import get_gpu_snapshot
+from fastvideo_studio.gpu import get_cluster_snapshot, get_gpu_snapshot
 from fastvideo_studio.job_runner import JobRunner, JobStatus
-from fastvideo_studio.models import (CreateDatasetRequest, CreateJobRequest, SettingsUpdate, UpdateCaptionRequest,
-                                     model_label)
+from fastvideo_studio.models import (CreateDatasetRequest, CreateJobRequest, GeneratorRequest, SettingsUpdate,
+                                     UpdateCaptionRequest, model_label)
 
 logging.basicConfig(
     level=logging.INFO,
@@ -45,6 +45,67 @@ logger = logging.getLogger("fastvideo.studio.api")
 
 DEFAULT_OUTPUT_DIR = os.path.join(os.path.dirname(__file__), "..", "outputs", "ui_jobs")
 
+
+class _EngineLogBuffer:
+    """Thread-safe ring buffer over the server process's stdout/stderr.
+
+    Because ray relays worker output to the driver (log_to_driver), teeing the
+    server's own streams captures engine output from every rank on every node;
+    under the mp executor, worker logs arrive via the logging handlers which
+    also write to stderr.
+    """
+
+    def __init__(self, maxlen: int = 5000) -> None:
+        import collections
+        import threading
+        self._lines: collections.deque[str] = collections.deque(maxlen=maxlen)
+        self._dropped = 0
+        self._lock = threading.Lock()
+        self._partial = ""
+
+    on_line = None  # optional callable(str), set once at startup
+
+    def write(self, text: str) -> None:
+        with self._lock:
+            buf = self._partial + text
+            *complete, self._partial = buf.split("\n")
+            for line in complete:
+                if len(self._lines) == self._lines.maxlen:
+                    self._dropped += 1
+                self._lines.append(line)
+        if self.on_line is not None:
+            for line in complete:
+                # never break stdout on a bad feed
+                with contextlib.suppress(Exception):
+                    self.on_line(line)
+
+    def get_lines(self, after: int = 0) -> tuple[list[str], int]:
+        with self._lock:
+            total = self._dropped + len(self._lines)
+            start = max(0, after - self._dropped)
+            return list(self._lines)[start:], total
+
+
+class _Tee:
+    """File-like that forwards to the original stream and the ring buffer."""
+
+    def __init__(self, orig: Any, buffer: _EngineLogBuffer) -> None:
+        self._orig = orig
+        self._buffer = buffer
+
+    def write(self, text: str) -> int:
+        self._buffer.write(text)
+        return self._orig.write(text)
+
+    def flush(self) -> None:
+        self._orig.flush()
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._orig, name)
+
+
+engine_log = _EngineLogBuffer()
+
 _available_models: list[dict[str, str]] = [{
     "id": path,
     "label": model_label(path)
@@ -102,6 +163,13 @@ def list_gpus() -> dict[str, Any]:
     return get_gpu_snapshot()
 
 
+@app.get("/api/cluster")
+def cluster_status() -> dict[str, Any]:
+    """Cluster-wide GPU/host telemetry (per-node NVML via ray when connected,
+    the local host otherwise)."""
+    return get_cluster_snapshot()
+
+
 @app.get("/api/models")
 def list_models(workload_type: str | None = None) -> list[dict[str, Any]]:
     """Return the catalogue of available video-generation models.
@@ -116,6 +184,25 @@ def list_models(workload_type: str | None = None) -> list[dict[str, Any]]:
     return _available_models
 
 
+_PRESET_FIELDS = ("height", "width", "num_frames", "fps", "num_inference_steps", "guidance_scale", "guidance_rescale",
+                  "negative_prompt", "seed")
+_preset_cache: dict[str, dict[str, Any]] = {}
+
+
+@app.get("/api/models/presets")
+def model_presets(model_id: str) -> dict[str, Any]:
+    """The model's recommended sampling settings (config-only — never loads
+    weights). The UI populates the job form from these on model selection."""
+    if model_id not in _preset_cache:
+        from fastvideo.api.sampling_param import SamplingParam
+        try:
+            sp = SamplingParam.from_pretrained(model_id)
+        except Exception as exc:  # noqa: BLE001 -- unknown/unresolvable model
+            raise HTTPException(status_code=404, detail=f"No presets for '{model_id}': {exc}") from exc
+        _preset_cache[model_id] = {f: getattr(sp, f) for f in _PRESET_FIELDS if getattr(sp, f, None) is not None}
+    return _preset_cache[model_id]
+
+
 ALLOWED_IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp", ".bmp"}
 
 
@@ -253,13 +340,58 @@ def get_job(job_id: str) -> dict[str, Any]:
     return job.to_dict()
 
 
+@app.get("/api/generators")
+def list_generators() -> list[dict[str, Any]]:
+    """Generators resident in memory plus preloads in flight or failed."""
+    return job_runner.list_generators()
+
+
+@app.post("/api/generators/preload", status_code=202)
+def preload_generator(req: GeneratorRequest) -> dict[str, Any]:
+    """Load a model into memory ahead of time (replacing whatever is
+    resident). One load at a time — 409 while another load is in flight."""
+    valid_ids = {m["id"] for m in _available_models}
+    if req.model_id not in valid_ids and not os.path.isdir(req.model_id):
+        raise HTTPException(
+            status_code=400,
+            detail=(f"Unknown model_id '{req.model_id}'. "
+                    f"Valid options: {sorted(valid_ids)}"),
+        )
+    try:
+        return job_runner.preload_generator(**req.model_dump())
+    except RuntimeError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+
+@app.post("/api/generators/unload")
+def unload_generator() -> dict[str, Any]:
+    """Shut down and delete the resident generator, freeing GPU memory."""
+    try:
+        unloaded = job_runner.unload_generator()
+    except RuntimeError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    if not unloaded:
+        raise HTTPException(status_code=404, detail="No model is loaded")
+    return {"unloaded": True}
+
+
+@app.get("/api/engine/logs")
+def engine_logs(after: int = 0) -> dict[str, Any]:
+    """Incremental tail of the engine's stdout/stderr (driver + relayed
+    worker output). Poll with ?after=<total from the previous response>."""
+    lines, total = engine_log.get_lines(after=after)
+    return {"lines": lines, "total": total}
+
+
 @app.post("/api/jobs", status_code=201)
 def create_job(req: CreateJobRequest) -> dict[str, Any]:
     """Create a new job (does **not** start it automatically)."""
     job_type = req.job_type or "inference"
     if job_type == "inference":
         valid_ids = {m["id"] for m in _available_models}
-        if req.model_id not in valid_ids:
+        # A local weights directory is as valid as a registered hub id —
+        # the registry resolves the pipeline from its model_index.
+        if req.model_id not in valid_ids and not os.path.isdir(req.model_id):
             raise HTTPException(
                 status_code=400,
                 detail=(f"Unknown model_id '{req.model_id}'. "
@@ -622,6 +754,14 @@ def create_local_env(host: str, port: int) -> None:
 
 
 def main() -> None:
+    import sys
+    sys.stdout = _Tee(sys.stdout, engine_log)
+    sys.stderr = _Tee(sys.stderr, engine_log)
+    # handlers created before the tee (module-level basicConfig) hold the
+    # original stream objects — re-point them or their output bypasses the buffer
+    for h in logging.getLogger().handlers:
+        if isinstance(h, logging.StreamHandler) and h.stream in (sys.__stderr__, sys.__stdout__):
+            h.setStream(sys.stderr)  # type: ignore[arg-type]  # duck-typed file-like
     global job_runner, database, upload_dir, verbose, datasets_upload_dir  # noqa: PLW0603
 
     # Set up signal handlers to prevent worker crashes from killing the server
@@ -686,6 +826,9 @@ def main() -> None:
         verbose=args.verbose,
         database=database,
     )
+    # ray relays worker output (incl. denoising tqdm) to the driver's stdout;
+    # feed those lines to the running job so the UI progress bar moves.
+    engine_log.on_line = job_runner.feed_engine_line
 
     logger.info("Output directory: %s", output_dir)
     logger.info("Log directory: %s", log_dir)
@@ -695,6 +838,10 @@ def main() -> None:
         host=args.host,
         port=args.port,
         log_level="info",
+        # The engine-output console tails this process's stdout/stderr; the
+        # frontend polls several endpoints every few seconds, so access-log
+        # lines are pure self-noise there. App/job logging is unaffected.
+        access_log=False,
     )
 
 

apps/fastvideo_studio/src/app/gpus/page.test.tsx

@@ -0,0 +1,182 @@
+import { render, screen } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import GpusPage from './page';
+import { getClusterStatus } from '@/lib/api';
+import type { ClusterSnapshot } from '@/lib/api';
+
+vi.mock('@/lib/api', () => ({
+  getClusterStatus: vi.fn(),
+}));
+
+const RAY_SNAPSHOT: ClusterSnapshot = {
+  mode: 'ray',
+  error: null,
+  resources: { gpus_total: 8, gpus_available: 5 },
+  nodes: [
+    {
+      hostname: 'node-a',
+      ip: '10.0.0.10',
+      is_this_host: true,
+      cpus: 64,
+      ray_gpus: 4,
+      available: true,
+      error: null,
+      gpus: [
+        {
+          index: 0,
+          name: 'NVIDIA B200',
+          utilization: 62,
+          memory_used_mib: 40_960,
+          memory_total_mib: 81_920,
+          temperature_c: 41,
+          power_watts: 312.4,
+          power_limit_watts: 1000,
+        },
+        {
+          index: 1,
+          name: 'NVIDIA B200',
+          utilization: 0,
+          memory_used_mib: 1_024,
+          memory_total_mib: 81_920,
+          temperature_c: null,
+          power_watts: null,
+          power_limit_watts: null,
+        },
+      ],
+    },
+    {
+      hostname: 'node-b',
+      ip: '10.0.0.11',
+      is_this_host: false,
+      cpus: 32,
+      ray_gpus: 2,
+      available: true,
+      error: null,
+      gpus: [
+        {
+          index: 0,
+          name: 'NVIDIA B200',
+          utilization: 90,
+          memory_used_mib: 20_480,
+          memory_total_mib: 81_920,
+          temperature_c: 70,
+          power_watts: 900,
+          power_limit_watts: 1000,
+        },
+      ],
+    },
+  ],
+};
+
+const LOCAL_SNAPSHOT: ClusterSnapshot = {
+  mode: 'local',
+  error:
+    'not connected to a ray cluster yet (load a model first); showing the API host only',
+  resources: null,
+  nodes: [
+    {
+      hostname: 'localhost',
+      ip: null,
+      is_this_host: true,
+      cpus: null,
+      ray_gpus: null,
+      available: true,
+      error: null,
+      gpus: [
+        {
+          index: 0,
+          name: 'NVIDIA RTX 5090',
+          utilization: 12,
+          memory_used_mib: 2_048,
+          memory_total_mib: 32_768,
+          temperature_c: 38,
+          power_watts: 80,
+          power_limit_watts: 575,
+        },
+      ],
+    },
+  ],
+};
+
+beforeEach(() => {
+  vi.mocked(getClusterStatus).mockResolvedValue(RAY_SNAPSHOT);
+});
+
+describe('GpusPage', () => {
+  it('renders the header with mode and GPU totals', async () => {
+    render(<GpusPage />);
+
+    expect(await screen.findByText('ray cluster')).toBeInTheDocument();
+    expect(screen.getByText(/5 \/\s*8 GPUs available/)).toBeInTheDocument();
+  });
+
+  it('renders a section per node with host details and GPU rows', async () => {
+    render(<GpusPage />);
+
+    // Each hostname appears twice: once in the strip, once as a section.
+    expect(await screen.findAllByText('node-a')).toHaveLength(2);
+    expect(screen.getAllByText('node-b')).toHaveLength(2);
+    expect(screen.getByText('10.0.0.10')).toBeInTheDocument();
+    // Only node-a is the API host.
+    expect(screen.getAllByText('API host')).toHaveLength(1);
+    expect(screen.getByText(/64 CPUs · 4 ray GPUs/)).toBeInTheDocument();
+
+    expect(screen.getAllByText('NVIDIA B200')).toHaveLength(3);
+    expect(screen.getByText('GPU 1')).toBeInTheDocument();
+    expect(screen.getByText('62%')).toBeInTheDocument();
+    expect(
+      screen.getByText('40960 / 81920 MiB (40.0 GiB / 80.0 GiB)'),
+    ).toBeInTheDocument();
+    // Optional sensors render only when present.
+    expect(screen.getByText('41°C')).toBeInTheDocument();
+    expect(screen.getByText('312 W / 1000 W')).toBeInTheDocument();
+  });
+
+  it('bars reflect utilization and VRAM values', async () => {
+    render(<GpusPage />);
+    await screen.findAllByText('node-a');
+
+    const utilMeters = screen
+      .getAllByRole('meter', { name: 'Utilization' })
+      .map((m) => m.getAttribute('aria-valuenow'));
+    expect(utilMeters).toEqual(['62', '0', '90']);
+
+    const vramMeters = screen
+      .getAllByRole('meter', { name: 'VRAM' })
+      .map((m) => m.getAttribute('aria-valuenow'));
+    // 40960/81920 = 50%, 1024/81920 ≈ 1%, 20480/81920 = 25%
+    expect(vramMeters).toEqual(['50', '1', '25']);
+  });
+
+  it('renders the compact strip with per-GPU segments', async () => {
+    render(<GpusPage />);
+    await screen.findAllByText('node-a');
+
+    const segments = screen.getAllByRole('img');
+    expect(segments).toHaveLength(3);
+    expect(segments[0]).toHaveAccessibleName(
+      'GPU 0: 62% utilization, 40.0 GiB / 80.0 GiB VRAM',
+    );
+  });
+
+  it('shows the informational banner and local mode', async () => {
+    vi.mocked(getClusterStatus).mockResolvedValue(LOCAL_SNAPSHOT);
+    render(<GpusPage />);
+
+    expect(await screen.findByText('local host only')).toBeInTheDocument();
+    expect(
+      screen.getByText(/not connected to a ray cluster yet/),
+    ).toBeInTheDocument();
+    // No resources in local mode.
+    expect(screen.queryByText(/GPUs available/)).not.toBeInTheDocument();
+  });
+
+  it('explains when the API server is unreachable', async () => {
+    vi.mocked(getClusterStatus).mockRejectedValue(new Error('network down'));
+    render(<GpusPage />);
+    expect(
+      await screen.findByText(/Could not reach the API server/),
+    ).toBeInTheDocument();
+  });
+});

apps/fastvideo_studio/src/app/gpus/page.tsx

@@ -1,11 +1,258 @@
 'use client';
 
-import GpuGrid from '@/components/system/GpuGrid';
+import * as React from 'react';
+import { AlertTriangle, Info } from 'lucide-react';
 
-export default function GpusPage() {
+import ClusterStrip, {
+  clampPercent,
+  formatGib,
+  utilizationColor,
+} from '@/components/cluster/ClusterStrip';
+import { Badge } from '@/components/ui/badge';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent } from '@/components/ui/card';
+import {
+  getClusterStatus,
+  type ClusterGpu,
+  type ClusterNode,
+  type ClusterSnapshot,
+} from '@/lib/api';
+import { cn } from '@/lib/utils';
+
+const POLL_INTERVAL_MS = 5000;
+
+function Meter({
+  label,
+  percent,
+  detail,
+  fillClass,
+}: {
+  label: string;
+  percent: number;
+  detail: string;
+  fillClass: string;
+}) {
+  const clamped = clampPercent(percent);
   return (
+    <div className="flex flex-col gap-1">
+      <div className="flex items-baseline justify-between gap-2 text-xs">
+        <span className="text-muted-foreground">{label}</span>
+        <span className="font-medium tabular-nums text-foreground">
+          {detail}
+        </span>
+      </div>
+      <div
+        role="meter"
+        aria-label={label}
+        aria-valuenow={Math.round(clamped)}
+        aria-valuemin={0}
+        aria-valuemax={100}
+        className="h-1.5 overflow-hidden rounded-full bg-muted"
+      >
+        <div
+          className={cn(
+            'h-full rounded-full transition-[width] duration-500',
+            fillClass,
+          )}
+          style={{ width: `${clamped}%` }}
+        />
+      </div>
+    </div>
+  );
+}
+
+function GpuRow({ gpu }: { gpu: ClusterGpu }) {
+  const memPercent =
+    gpu.memory_total_mib > 0
+      ? (gpu.memory_used_mib / gpu.memory_total_mib) * 100
+      : 0;
+  return (
+    <div className="grid items-center gap-x-6 gap-y-2 border-t border-border pt-3 first:border-t-0 first:pt-0 md:grid-cols-[minmax(0,1fr)_minmax(0,1.2fr)_minmax(0,1.6fr)_auto]">
+      <div className="flex min-w-0 items-baseline gap-2">
+        <span className="min-w-0 truncate text-sm font-semibold">
+          {gpu.name}
+        </span>
+        <span className="shrink-0 text-xs font-medium uppercase tracking-wider text-muted-foreground">
+          GPU {gpu.index}
+        </span>
+      </div>
+      <Meter
+        label="Utilization"
+        percent={gpu.utilization}
+        detail={`${gpu.utilization}%`}
+        fillClass={utilizationColor(gpu.utilization)}
+      />
+      <Meter
+        label="VRAM"
+        percent={memPercent}
+        detail={`${gpu.memory_used_mib} / ${gpu.memory_total_mib} MiB (${formatGib(gpu.memory_used_mib)} / ${formatGib(gpu.memory_total_mib)})`}
+        fillClass={memPercent >= 90 ? 'bg-rose-500' : 'bg-accent-blue'}
+      />
+      <div className="flex flex-wrap gap-x-4 gap-y-1 text-xs tabular-nums text-muted-foreground md:w-28 md:justify-end">
+        {gpu.temperature_c != null && <span>{gpu.temperature_c}°C</span>}
+        {gpu.power_watts != null && (
+          <span>
+            {Math.round(gpu.power_watts)} W
+            {gpu.power_limit_watts != null &&
+              ` / ${Math.round(gpu.power_limit_watts)} W`}
+          </span>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function NodeSection({ node }: { node: ClusterNode }) {
+  return (
+    <Card>
+      <CardContent className="flex flex-col gap-3 p-5">
+        <div className="flex flex-wrap items-center gap-x-3 gap-y-1">
+          <span className="min-w-0 truncate text-sm font-semibold">
+            {node.hostname}
+          </span>
+          {node.ip && (
+            <span className="text-xs tabular-nums text-muted-foreground">
+              {node.ip}
+            </span>
+          )}
+          {node.is_this_host && <Badge variant="secondary">API host</Badge>}
+          <span className="ml-auto text-xs tabular-nums text-muted-foreground">
+            {node.cpus != null && `${Math.round(node.cpus)} CPUs`}
+            {node.cpus != null && node.ray_gpus != null && ' · '}
+            {node.ray_gpus != null && `${Math.round(node.ray_gpus)} ray GPUs`}
+          </span>
+        </div>
+        {!node.available && (
+          <p className="text-sm text-muted-foreground">
+            GPU telemetry unavailable
+            {node.error ? `: ${node.error}` : '.'}
+          </p>
+        )}
+        {node.gpus.map((gpu) => (
+          <GpuRow key={gpu.index} gpu={gpu} />
+        ))}
+      </CardContent>
+    </Card>
+  );
+}
+
+export default function GpusPage() {
+  const [snapshot, setSnapshot] = React.useState<ClusterSnapshot | null>(null);
+  const [fetchError, setFetchError] = React.useState<string | null>(null);
+  const [retryToken, setRetryToken] = React.useState(0);
+
+  React.useEffect(() => {
+    let mounted = true;
+    let inFlight = false;
+
+    async function poll() {
+      if (inFlight || document.hidden) return;
+      inFlight = true;
+      try {
+        const next = await getClusterStatus();
+        if (mounted) {
+          setSnapshot(next);
+          setFetchError(null);
+        }
+      } catch {
+        if (mounted) {
+          setFetchError(
+            'Cluster status could not be refreshed. The values below may be stale.',
+          );
+        }
+      } finally {
+        inFlight = false;
+      }
+    }
+
+    poll();
+    const interval = setInterval(poll, POLL_INTERVAL_MS);
+    // Refresh immediately when the tab becomes visible again (polls are
+    // skipped while hidden).
+    document.addEventListener('visibilitychange', poll);
+    return () => {
+      mounted = false;
+      clearInterval(interval);
+      document.removeEventListener('visibilitychange', poll);
+    };
+  }, [retryToken]);
+
+  let body: React.ReactNode;
+  if (fetchError && !snapshot) {
+    body = (
+      <div
+        role="alert"
+        className="flex flex-col items-center gap-3 py-8 text-center"
+      >
+        <AlertTriangle className="size-6 text-destructive" aria-hidden />
+        <p className="text-muted-foreground">
+          Could not reach the API server. Cluster status needs the Studio API
+          server running.
+        </p>
+        <Button
+          type="button"
+          variant="outline"
+          onClick={() => setRetryToken((token) => token + 1)}
+        >
+          Try Again
+        </Button>
+      </div>
+    );
+  } else if (!snapshot) {
+    body = <p className="py-8 text-center text-muted-foreground">Loading…</p>;
+  } else {
+    body = (
+      <div className="flex flex-col gap-4">
+        <header className="flex flex-wrap items-center gap-3">
+          <h1 className="text-lg font-semibold">Cluster</h1>
+          <Badge variant="outline">
+            {snapshot.mode === 'ray' ? 'ray cluster' : 'local host only'}
+          </Badge>
+          {snapshot.resources && (
+            <span className="text-sm tabular-nums text-muted-foreground">
+              {Math.round(snapshot.resources.gpus_available)} /{' '}
+              {Math.round(snapshot.resources.gpus_total)} GPUs available
+            </span>
+          )}
+        </header>
+        {snapshot.error && (
+          <div
+            role="status"
+            className="flex flex-wrap items-center gap-3 rounded-lg border border-blue-400/40 bg-blue-500/10 px-3 py-2 text-sm"
+          >
+            <Info className="size-4 shrink-0 text-blue-600" aria-hidden />
+            <span className="min-w-0 flex-1">{snapshot.error}</span>
+          </div>
+        )}
+        {fetchError && (
+          <div
+            role="status"
+            aria-live="polite"
+            className="flex flex-wrap items-center gap-3 rounded-lg border border-amber-500/50 bg-amber-500/10 px-3 py-2 text-sm"
+          >
+            <AlertTriangle className="size-4 text-amber-600" aria-hidden />
+            <span className="min-w-0 flex-1">{fetchError}</span>
+            <Button
+              type="button"
+              variant="outline"
+              size="sm"
+              onClick={() => setRetryToken((token) => token + 1)}
+            >
+              Refresh Now
+            </Button>
+          </div>
+        )}
+        <ClusterStrip nodes={snapshot.nodes} />
+        {snapshot.nodes.map((node, i) => (
+          <NodeSection key={`${node.hostname}-${i}`} node={node} />
+        ))}
+      </div>
+    );
+  }
+
+  return (
     <div className="mx-auto flex w-full max-w-[1100px] flex-col gap-6 px-4 pb-12 pt-6">
-      <GpuGrid />
+      {body}
     </div>
   );
 }

apps/fastvideo_studio/src/app/inference/page.tsx

@@ -1,8 +1,10 @@
 'use client';
 
 import CreateJobButton from '@/components/jobs/CreateJobButton';
+import EngineConsole from '@/components/jobs/EngineConsole';
 import { HeaderActions } from '@/components/shell/HeaderActionsContext';
 import JobQueue from '@/components/jobs/JobQueue';
+import WarmModelsPanel from '@/components/jobs/WarmModelsPanel';
 
 export default function InferencePage() {
   return (
@@ -10,6 +12,8 @@ export default function InferencePage() {
       <HeaderActions>
         <CreateJobButton jobType="inference" />
       </HeaderActions>
+      <WarmModelsPanel />
+      <EngineConsole />
       <JobQueue jobType="inference" />
     </>
   );

apps/fastvideo_studio/src/components/cluster/ClusterStrip.tsx

@@ -0,0 +1,93 @@
+'use client';
+
+import type { ClusterNode } from '@/lib/api';
+import { cn } from '@/lib/utils';
+
+export function formatGib(mib: number): string {
+  return `${(mib / 1024).toFixed(1)} GiB`;
+}
+
+/** Bar fill class by load: blue when idle, amber under pressure, rose hot. */
+export function utilizationColor(percent: number): string {
+  if (percent >= 85) return 'bg-rose-500';
+  if (percent >= 50) return 'bg-amber-500';
+  return 'bg-accent-blue';
+}
+
+export function clampPercent(percent: number): number {
+  return Math.max(0, Math.min(100, percent));
+}
+
+function GpuSegment({
+  index,
+  utilization,
+  memUsedMib,
+  memTotalMib,
+}: {
+  index: number;
+  utilization: number;
+  memUsedMib: number;
+  memTotalMib: number;
+}) {
+  const memPercent =
+    memTotalMib > 0 ? clampPercent((memUsedMib / memTotalMib) * 100) : 0;
+  const label =
+    `GPU ${index}: ${utilization}% utilization, ` +
+    `${formatGib(memUsedMib)} / ${formatGib(memTotalMib)} VRAM`;
+  return (
+    <div
+      role="img"
+      aria-label={label}
+      title={label}
+      className="flex w-10 shrink-0 flex-col gap-0.5"
+    >
+      <div className="h-1.5 overflow-hidden rounded-full bg-muted">
+        <div
+          className={cn('h-full rounded-full', utilizationColor(utilization))}
+          style={{ width: `${clampPercent(utilization)}%` }}
+        />
+      </div>
+      <div className="h-1.5 overflow-hidden rounded-full bg-muted">
+        <div
+          className={cn(
+            'h-full rounded-full',
+            memPercent >= 90 ? 'bg-rose-500' : 'bg-accent-blue',
+          )}
+          style={{ width: `${memPercent}%` }}
+        />
+      </div>
+    </div>
+  );
+}
+
+/** One compact line per node: hostname + tiny util/VRAM bars per GPU. */
+export default function ClusterStrip({ nodes }: { nodes: ClusterNode[] }) {
+  return (
+    <div className="flex flex-col gap-2">
+      {nodes.map((node, i) => (
+        <div
+          key={`${node.hostname}-${i}`}
+          className="flex items-center gap-3"
+        >
+          <span className="w-40 shrink-0 truncate text-xs font-medium">
+            {node.hostname}
+          </span>
+          <div className="flex min-w-0 flex-wrap items-center gap-1.5">
+            {node.gpus.map((gpu) => (
+              <GpuSegment
+                key={gpu.index}
+                index={gpu.index}
+                utilization={gpu.utilization}
+                memUsedMib={gpu.memory_used_mib}
+                memTotalMib={gpu.memory_total_mib}
+              />
+            ))}
+            {node.gpus.length === 0 && (
+              <span className="text-xs text-muted-foreground">no GPUs</span>
+            )}
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}

apps/fastvideo_studio/src/components/jobs/CreateJobModal.test.tsx

@@ -4,14 +4,24 @@ import userEvent from '@testing-library/user-event';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import CreateJobModal from './CreateJobModal';
-import { createJob, getDatasets, getModels, uploadImage } from '@/lib/api';
+import {
+  createJob,
+  getDatasets,
+  getModelPresets,
+  getModels,
+  listGenerators,
+  uploadImage,
+  type GeneratorInfo,
+} from '@/lib/api';
 import { defaultOptionsStore } from '@/stores/defaultOptions';
 import { DEFAULT_OPTIONS } from '@/lib/defaultOptions';
 
 vi.mock('@/lib/api', () => ({
   createJob: vi.fn(),
   getModels: vi.fn(),
+  getModelPresets: vi.fn(),
   getDatasets: vi.fn(),
+  listGenerators: vi.fn(),
   uploadImage: vi.fn(),
   getSettings: vi.fn(),
   updateSettings: vi.fn(),
@@ -22,11 +32,32 @@ const MODELS = [
   { id: 'wan/t2v-14b', label: 'Wan T2V Large', type: 't2v' },
 ];
 
+// A resident engine slot whose engine config differs from the persisted
+// defaults on every field the modal adopts.
+const WARM_SLOT: GeneratorInfo = {
+  state: 'ready',
+  model_id: 'wan/t2v-14b',
+  workload_type: 't2v',
+  num_gpus: 8,
+  dit_cpu_offload: true,
+  text_encoder_cpu_offload: true,
+  vae_cpu_offload: true,
+  image_encoder_cpu_offload: false,
+  use_fsdp_inference: true,
+  enable_torch_compile: true,
+  vsa_sparsity: 0.5,
+  tp_size: 1,
+  sp_size: 8,
+  error: null,
+};
+
 beforeEach(() => {
   // Reset the shared options store to a known baseline for test isolation.
   defaultOptionsStore.set({ options: DEFAULT_OPTIONS });
   vi.mocked(getModels).mockResolvedValue(MODELS);
+  vi.mocked(getModelPresets).mockResolvedValue({});
   vi.mocked(getDatasets).mockResolvedValue([]);
+  vi.mocked(listGenerators).mockResolvedValue([]);
   vi.mocked(uploadImage).mockResolvedValue({ path: '/uploads/x.png' });
   vi.mocked(createJob).mockResolvedValue({ id: 'job-1' } as never);
 });
@@ -206,4 +237,173 @@ describe('CreateJobModal', () => {
 
     await waitFor(() => expect(onSuccess).toHaveBeenCalledTimes(1));
   });
+
+  it('defaults to the warm resident model and adopts its engine config', async () => {
+    vi.mocked(listGenerators).mockResolvedValue([WARM_SLOT]);
+
+    const user = userEvent.setup();
+    renderModal();
+
+    // Without a warm model the default logic picks the first model
+    // (wan/t2v-1.3b, covered by the seeding test above); the warm slot wins.
+    await waitFor(() =>
+      expect(screen.getByLabelText('Model')).toHaveValue('wan/t2v-14b'),
+    );
+    // The warm selection also triggers its presets fetch.
+    await waitFor(() =>
+      expect(getModelPresets).toHaveBeenCalledWith('wan/t2v-14b'),
+    );
+
+    await user.type(screen.getByLabelText('Prompt'), 'warm run');
+    await user.click(screen.getByRole('button', { name: 'Create Job' }));
+
+    await waitFor(() => expect(createJob).toHaveBeenCalledTimes(1));
+    // The engine fields mirror the resident slot (not the persisted defaults:
+    // num_gpus 1, all offloads/fsdp/compile false) so the job reuses the warm
+    // instance instead of replacing it.
+    expect(vi.mocked(createJob).mock.calls[0][0]).toMatchObject({
+      model_id: 'wan/t2v-14b',
+      num_gpus: 8,
+      tp_size: 1,
+      sp_size: 8,
+      dit_cpu_offload: true,
+      text_encoder_cpu_offload: true,
+      vae_cpu_offload: true,
+      image_encoder_cpu_offload: false,
+      use_fsdp_inference: true,
+      enable_torch_compile: true,
+      vsa_sparsity: 0.5,
+    });
+  });
+
+  it('restores persisted-default engine fields when switching away from the warm model', async () => {
+    defaultOptionsStore.set({
+      options: { ...DEFAULT_OPTIONS, numGpus: 2, tpSize: 2 },
+    });
+    vi.mocked(listGenerators).mockResolvedValue([WARM_SLOT]);
+
+    const user = userEvent.setup();
+    renderModal();
+
+    await waitFor(() =>
+      expect(screen.getByLabelText('Model')).toHaveValue('wan/t2v-14b'),
+    );
+    await user.selectOptions(screen.getByLabelText('Model'), 'wan/t2v-1.3b');
+    await user.type(screen.getByLabelText('Prompt'), 'cold run');
+    await user.click(screen.getByRole('button', { name: 'Create Job' }));
+
+    await waitFor(() => expect(createJob).toHaveBeenCalledTimes(1));
+    expect(vi.mocked(createJob).mock.calls[0][0]).toMatchObject({
+      model_id: 'wan/t2v-1.3b',
+      num_gpus: 2,
+      tp_size: 2,
+      use_fsdp_inference: false,
+      enable_torch_compile: false,
+    });
+  });
+
+  it('applies resolution preset chips and the orientation toggle to the payload', async () => {
+    const user = userEvent.setup();
+    renderModal();
+
+    await screen.findByRole('option', { name: 'Wan T2V (wan/t2v-1.3b)' });
+    await user.click(screen.getByText('Options'));
+
+    // 720p chip sets the /32-rounded dims; the orientation toggle swaps them.
+    await user.click(screen.getByRole('button', { name: '720p' }));
+    await user.click(screen.getByRole('button', { name: 'Landscape' }));
+    expect(
+      screen.getByRole('button', { name: 'Portrait' }),
+    ).toBeInTheDocument();
+
+    await user.type(screen.getByLabelText('Prompt'), 'portrait 720p');
+    await user.click(screen.getByRole('button', { name: 'Create Job' }));
+
+    await waitFor(() => expect(createJob).toHaveBeenCalledTimes(1));
+    expect(vi.mocked(createJob).mock.calls[0][0]).toMatchObject({
+      height: 1280,
+      width: 704,
+    });
+  });
+
+  it('restores the model preset resolution via the Native chip', async () => {
+    vi.mocked(getModelPresets).mockResolvedValue({ height: 720, width: 1280 });
+
+    const user = userEvent.setup();
+    renderModal();
+
+    await screen.findByRole('option', { name: 'Wan T2V (wan/t2v-1.3b)' });
+    // Native is disabled until the selected model's presets have loaded.
+    await waitFor(() =>
+      expect(screen.getByRole('button', { name: 'Native' })).toBeEnabled(),
+    );
+    await user.click(screen.getByText('Options'));
+
+    await user.click(screen.getByRole('button', { name: '1080p' }));
+    await user.click(screen.getByRole('button', { name: 'Native' }));
+
+    await user.type(screen.getByLabelText('Prompt'), 'native dims');
+    await user.click(screen.getByRole('button', { name: 'Create Job' }));
+
+    await waitFor(() => expect(createJob).toHaveBeenCalledTimes(1));
+    expect(vi.mocked(createJob).mock.calls[0][0]).toMatchObject({
+      height: 720,
+      width: 1280,
+    });
+  });
+
+  it('populates sampling fields from the selected model presets; engine fields stay from defaults', async () => {
+    defaultOptionsStore.set({
+      options: { ...DEFAULT_OPTIONS, numGpus: 4, tpSize: 2, seed: 999 },
+    });
+    vi.mocked(getModelPresets).mockImplementation(async (id) =>
+      id === 'wan/t2v-14b'
+        ? {
+            height: 720,
+            width: 1280,
+            num_frames: 121,
+            fps: 30,
+            num_inference_steps: 40,
+            guidance_scale: 6,
+            guidance_rescale: 0.5,
+            negative_prompt: 'blurry, low quality',
+            seed: 7,
+          }
+        : {},
+    );
+
+    const user = userEvent.setup();
+    renderModal();
+
+    await screen.findByRole('option', { name: 'Wan T2V Large (wan/t2v-14b)' });
+    await user.selectOptions(screen.getByLabelText('Model'), 'wan/t2v-14b');
+    // The negative prompt is the easiest preset-populated field to observe.
+    await waitFor(() =>
+      expect(screen.getByLabelText('Negative Prompt')).toHaveValue(
+        'blurry, low quality',
+      ),
+    );
+
+    await user.type(screen.getByLabelText('Prompt'), 'preset test');
+    await user.click(screen.getByRole('button', { name: 'Create Job' }));
+
+    await waitFor(() => expect(createJob).toHaveBeenCalledTimes(1));
+    const payload = vi.mocked(createJob).mock.calls[0][0];
+    expect(payload).toMatchObject({
+      model_id: 'wan/t2v-14b',
+      // Sampling fields come from the model presets…
+      height: 720,
+      width: 1280,
+      num_frames: 121,
+      fps: 30,
+      num_inference_steps: 40,
+      guidance_scale: 6,
+      guidance_rescale: 0.5,
+      negative_prompt: 'blurry, low quality',
+      seed: 7,
+      // …while engine fields still come from the persisted defaults.
+      num_gpus: 4,
+      tp_size: 2,
+    });
+  });
 });

apps/fastvideo_studio/src/components/jobs/CreateJobModal.tsx

@@ -23,15 +23,27 @@ import { defaultOptionsStore } from '@/stores/defaultOptions';
 import {
   createJob,
   getDatasets,
+  getModelPresets,
   getModels,
+  listGenerators,
   uploadImage,
   type CreateJobRequest,
+  type GeneratorInfo,
   type Model,
 } from '@/lib/api';
 import { getDefaultModelForWorkload } from '@/lib/defaultOptions';
 import { WORKLOAD_OPTIONS } from '@/lib/jobConfig';
 import type { JobType } from '@/lib/types';
 
+// ponytail: dims pre-rounded to multiples of 32 so every model family accepts
+// them (H3 requires /32) — hence 720p→704 and 1080p→1088. Tooltips show the
+// exact dims; the labels stay 480p/720p/1080p.
+const RESOLUTION_PRESETS = [
+  { label: '480p', height: 480, width: 832 },
+  { label: '720p', height: 704, width: 1280 },
+  { label: '1080p', height: 1088, width: 1920 },
+] as const;
+
 export interface CreateJobModalProps {
   isOpen: boolean;
   onClose: () => void;
@@ -55,6 +67,9 @@ export default function CreateJobModal({
 
   const [models, setModels] = React.useState<Model[]>([]);
   const [modelId, setModelId] = React.useState('');
+  // The engine's resident slot (null when empty/failed), fetched on open so
+  // jobs against the warm model can adopt its engine config.
+  const [warmSlot, setWarmSlot] = React.useState<GeneratorInfo | null>(null);
   const [prompt, setPrompt] = React.useState('');
   const [imagePath, setImagePath] = React.useState('');
   const [imageFileName, setImageFileName] = React.useState('');
@@ -64,6 +79,12 @@ export default function CreateJobModal({
   const [numFrames, setNumFrames] = React.useState(81);
   const [height, setHeight] = React.useState(480);
   const [width, setWidth] = React.useState(832);
+  // The selected model's preset dims, kept so the "Native" chip can restore
+  // them after a resolution chip or manual slider edit.
+  const [nativeDims, setNativeDims] = React.useState<{
+    height: number;
+    width: number;
+  } | null>(null);
   const [guidanceScale, setGuidanceScale] = React.useState(5);
   const [guidanceRescale, setGuidanceRescale] = React.useState(0);
   const [fps, setFps] = React.useState(24);
@@ -178,17 +199,34 @@ export default function CreateJobModal({
     let stale = false;
     setIsLoadingModels(true);
     setModelLoadError(null);
-    getModels(inferenceWorkload)
-      .then((list) => {
+    // For inference jobs, prefer the warm resident model (if any) over the
+    // persisted default so new jobs hit the already-loaded engine. The warm
+    // slot is a nice-to-have: if the lookup fails, fall back silently.
+    const warmSlotPromise = isInference
+      ? listGenerators()
+          .then((gens) =>
+            gens[0] && gens[0].state !== 'failed' ? gens[0] : null,
+          )
+          .catch(() => null)
+      : Promise.resolve(null);
+    Promise.all([getModels(inferenceWorkload), warmSlotPromise])
+      .then(([list, slot]) => {
         if (stale) return;
         setModels(list);
+        setWarmSlot(slot);
         const ids = list.map((m) => m.id);
         const opts = defaultOptionsStore.get().options;
         const defaultId = getDefaultModelForWorkload(
           opts,
           inferenceWorkload as 't2v' | 'i2v' | 't2i',
         );
-        const chosen = ids.includes(defaultId) ? defaultId : (list[0]?.id ?? '');
+        const warmId = slot?.model_id ?? '';
+        const chosen =
+          warmId && ids.includes(warmId)
+            ? warmId
+            : ids.includes(defaultId)
+              ? defaultId
+              : (list[0]?.id ?? '');
         setModelId(chosen);
         if (workloadType === 'dmd_t2v') {
           setRealScoreModelPath(chosen);
@@ -210,7 +248,81 @@ export default function CreateJobModal({
     return () => {
       stale = true;
     };
-  }, [isOpen, inferenceWorkload, workloadType]);
+  }, [isOpen, isInference, inferenceWorkload, workloadType]);
+
+  // Whenever the selected model changes (including the initial selection on
+  // open), populate the sampling fields from that model's presets. Missing
+  // keys leave the field as-is; engine fields (GPUs, parallelism, offloads)
+  // come from the warm slot or persisted defaults (effect below). Latest
+  // selection wins: the cleanup marks superseded fetches stale, same as the
+  // model-list effect.
+  React.useEffect(() => {
+    if (!isOpen || !isInference || !modelId) return;
+    let stale = false;
+    setNativeDims(null);
+    getModelPresets(modelId)
+      .then((p) => {
+        if (stale) return;
+        if (p.height !== undefined) setHeight(p.height);
+        if (p.width !== undefined) setWidth(p.width);
+        if (p.height !== undefined && p.width !== undefined)
+          setNativeDims({ height: p.height, width: p.width });
+        if (p.num_frames !== undefined)
+          setNumFrames(workloadType === 't2i' ? 1 : p.num_frames);
+        if (p.fps !== undefined) setFps(p.fps);
+        if (p.num_inference_steps !== undefined)
+          setNumInferenceSteps(p.num_inference_steps);
+        if (p.guidance_scale !== undefined) setGuidanceScale(p.guidance_scale);
+        if (p.guidance_rescale !== undefined)
+          setGuidanceRescale(p.guidance_rescale);
+        if (p.negative_prompt !== undefined)
+          setNegativePrompt(p.negative_prompt);
+        if (p.seed !== undefined) setSeed(p.seed);
+      })
+      .catch((e) => {
+        // Presets are a convenience; on failure keep the current values.
+        console.error('Failed to load model presets:', e);
+      });
+    return () => {
+      stale = true;
+    };
+  }, [isOpen, isInference, modelId, workloadType]);
+
+  // When the selected model IS the warm resident one, adopt the slot's engine
+  // config so the job reuses the loaded instance instead of silently replacing
+  // it (e.g. persisted num_gpus=1 vs a warm 8-GPU slot). Switching away from
+  // the warm model restores the persisted-default engine fields; non-warm to
+  // non-warm switches leave the user's engine edits alone (today's behavior).
+  const wasWarmRef = React.useRef(false);
+  React.useEffect(() => {
+    if (!isOpen || !isInference || !modelId) return;
+    const isWarm = warmSlot?.model_id === modelId;
+    if (isWarm && warmSlot) {
+      setNumGpus(warmSlot.num_gpus);
+      setTpSize(warmSlot.tp_size);
+      setSpSize(warmSlot.sp_size);
+      setDitCpuOffload(warmSlot.dit_cpu_offload);
+      setTextEncoderCpuOffload(warmSlot.text_encoder_cpu_offload);
+      setVaeCpuOffload(warmSlot.vae_cpu_offload);
+      setImageEncoderCpuOffload(warmSlot.image_encoder_cpu_offload);
+      setUseFsdpInference(warmSlot.use_fsdp_inference);
+      setEnableTorchCompile(warmSlot.enable_torch_compile);
+      setVsaSparsity(warmSlot.vsa_sparsity);
+    } else if (wasWarmRef.current) {
+      const opts = defaultOptionsStore.get().options;
+      setNumGpus(opts.numGpus);
+      setTpSize(opts.tpSize);
+      setSpSize(opts.spSize);
+      setDitCpuOffload(opts.ditCpuOffload);
+      setTextEncoderCpuOffload(opts.textEncoderCpuOffload);
+      setVaeCpuOffload(opts.vaeCpuOffload);
+      setImageEncoderCpuOffload(opts.imageEncoderCpuOffload);
+      setUseFsdpInference(opts.useFsdpInference);
+      setEnableTorchCompile(opts.enableTorchCompile);
+      setVsaSparsity(opts.vsaSparsity);
+    }
+    wasWarmRef.current = isWarm;
+  }, [isOpen, isInference, modelId, warmSlot]);
 
   // Training jobs need a dataset; load the ready datasets when relevant.
   React.useEffect(() => {
@@ -741,6 +853,64 @@ export default function CreateJobModal({
                     disabled={isSubmitting}
                   />
                 )}
+                <div className="col-span-full flex flex-wrap items-center gap-1.5">
+                  <span className="pl-0.5 text-xs font-normal tracking-wide text-muted-foreground">
+                    Resolution
+                  </span>
+                  {RESOLUTION_PRESETS.map((preset) => (
+                    <Button
+                      key={preset.label}
+                      type="button"
+                      size="sm"
+                      variant="outline"
+                      title={`${preset.height}×${preset.width}`}
+                      onClick={() => {
+                        // Apply in the current orientation so a portrait
+                        // setup stays portrait when switching resolution.
+                        const portrait = height > width;
+                        setHeight(portrait ? preset.width : preset.height);
+                        setWidth(portrait ? preset.height : preset.width);
+                      }}
+                      disabled={isSubmitting}
+                      className="h-6 px-2 text-xs"
+                    >
+                      {preset.label}
+                    </Button>
+                  ))}
+                  <Button
+                    type="button"
+                    size="sm"
+                    variant="outline"
+                    title={
+                      nativeDims
+                        ? `${nativeDims.height}×${nativeDims.width}`
+                        : 'Model preset resolution (unavailable)'
+                    }
+                    onClick={() => {
+                      if (!nativeDims) return;
+                      setHeight(nativeDims.height);
+                      setWidth(nativeDims.width);
+                    }}
+                    disabled={isSubmitting || !nativeDims}
+                    className="h-6 px-2 text-xs"
+                  >
+                    Native
+                  </Button>
+                  <Button
+                    type="button"
+                    size="sm"
+                    variant="outline"
+                    title="Swap height and width"
+                    onClick={() => {
+                      setHeight(width);
+                      setWidth(height);
+                    }}
+                    disabled={isSubmitting}
+                    className="h-6 px-2 text-xs"
+                  >
+                    {height > width ? 'Portrait' : 'Landscape'}
+                  </Button>
+                </div>
                 <SliderRow
                   id="modal-height"
                   label="Height"

apps/fastvideo_studio/src/components/jobs/EngineConsole.test.tsx

@@ -0,0 +1,71 @@
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import EngineConsole from './EngineConsole';
+import { getEngineLogs } from '@/lib/api';
+
+vi.mock('@/lib/api', () => ({
+  getEngineLogs: vi.fn(),
+}));
+
+beforeEach(() => {
+  vi.mocked(getEngineLogs).mockResolvedValue({
+    lines: ['[engine] booted', '[engine] worker heartbeat ok'],
+    total: 2,
+  });
+});
+
+describe('EngineConsole', () => {
+  it('is collapsed by default and does not fetch', () => {
+    render(<EngineConsole />);
+
+    expect(
+      screen.getByRole('button', { name: 'Engine output' }),
+    ).toHaveAttribute('aria-expanded', 'false');
+    expect(getEngineLogs).not.toHaveBeenCalled();
+  });
+
+  it('shows log lines and polls with the cursor while open', async () => {
+    vi.useFakeTimers();
+    try {
+      render(<EngineConsole />);
+      fireEvent.click(screen.getByRole('button', { name: 'Engine output' }));
+
+      // Flush the immediate poll fired on expand.
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(0);
+      });
+      expect(getEngineLogs).toHaveBeenCalledWith(0);
+      expect(screen.getByText(/\[engine\] booted/)).toBeInTheDocument();
+
+      // The 2s interval polls again, from the previous total.
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(2000);
+      });
+      expect(getEngineLogs).toHaveBeenLastCalledWith(2);
+
+      // Collapsing stops the polling.
+      fireEvent.click(screen.getByRole('button', { name: 'Engine output' }));
+      const calls = vi.mocked(getEngineLogs).mock.calls.length;
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(10000);
+      });
+      expect(getEngineLogs).toHaveBeenCalledTimes(calls);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('clear view empties the scrollback locally', async () => {
+    const user = userEvent.setup();
+    render(<EngineConsole />);
+
+    await user.click(screen.getByRole('button', { name: 'Engine output' }));
+    expect(await screen.findByText(/\[engine\] booted/)).toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: 'Clear view' }));
+    expect(screen.queryByText(/\[engine\] booted/)).not.toBeInTheDocument();
+    expect(screen.getByText('Waiting for engine output…')).toBeInTheDocument();
+  });
+});

apps/fastvideo_studio/src/components/jobs/EngineConsole.tsx

@@ -0,0 +1,123 @@
+'use client';
+
+import * as React from 'react';
+import { ChevronDown, ChevronRight } from 'lucide-react';
+
+import { Button } from '@/components/ui/button';
+import { getEngineLogs } from '@/lib/api';
+
+const POLL_INTERVAL_MS = 2000;
+// Cap the DOM at the last ~500 lines; the server keeps its own ring buffer.
+const MAX_LINES = 500;
+
+// The engine tail includes uvicorn's access log (until a server restart picks
+// up access_log=False); the frontend's own polling would otherwise flood the
+// console with "GET /api/... 200 OK" lines. Keep non-GET and non-2xx lines.
+const ACCESS_LOG_NOISE = /^INFO:\s+[\d.:]+\s+- "(?:GET|HEAD) \S+ HTTP\/[\d.]+" 2\d\d/;
+
+/**
+ * Collapsible tail of the engine's stdout/stderr (driver + relayed worker
+ * output). Polls only while open; sticks to the bottom unless the user has
+ * scrolled up.
+ */
+export default function EngineConsole() {
+  const [open, setOpen] = React.useState(false);
+  const [lines, setLines] = React.useState<string[]>([]);
+  // Poll cursor + stick-to-bottom flag live in refs: they must update
+  // synchronously from async polls / scroll events, outside React's cycle.
+  const afterRef = React.useRef(0);
+  const stickRef = React.useRef(true);
+  const consoleRef = React.useRef<HTMLPreElement | null>(null);
+
+  React.useEffect(() => {
+    if (!open) return;
+    let mounted = true;
+    let locked = false;
+
+    async function poll() {
+      if (!mounted || locked) return;
+      locked = true;
+      try {
+        const data = await getEngineLogs(afterRef.current);
+        afterRef.current = data.total;
+        const fresh = data.lines.filter((l) => !ACCESS_LOG_NOISE.test(l));
+        if (mounted && fresh.length > 0) {
+          setLines((prev) => [...prev, ...fresh].slice(-MAX_LINES));
+        }
+      } catch (e) {
+        console.error('Failed to fetch engine logs:', e);
+      } finally {
+        locked = false;
+      }
+    }
+
+    poll();
+    const interval = setInterval(poll, POLL_INTERVAL_MS);
+    return () => {
+      mounted = false;
+      clearInterval(interval);
+    };
+  }, [open]);
+
+  // Follow the tail after new lines land, unless the user scrolled up.
+  React.useEffect(() => {
+    const el = consoleRef.current;
+    if (el && stickRef.current) el.scrollTop = el.scrollHeight;
+  }, [lines]);
+
+  function handleScroll() {
+    const el = consoleRef.current;
+    if (!el) return;
+    stickRef.current = el.scrollHeight - el.scrollTop - el.clientHeight < 40;
+  }
+
+  return (
+    <section
+      aria-label="Engine output"
+      className="mx-auto w-full max-w-[850px] px-10 pt-3"
+    >
+      <div className="rounded-lg border border-border bg-background">
+        <div className="flex items-center gap-2 px-2 py-1.5">
+          <button
+            type="button"
+            onClick={() => setOpen((o) => !o)}
+            aria-expanded={open}
+            className="flex flex-1 items-center gap-2 rounded-md px-2 py-1 text-sm font-semibold text-foreground hover:bg-accent"
+          >
+            {open ? (
+              <ChevronDown className="h-4 w-4" />
+            ) : (
+              <ChevronRight className="h-4 w-4" />
+            )}
+            Engine output
+          </button>
+          {open && (
+            <Button
+              size="sm"
+              variant="ghost"
+              // Resets the local view only; the server buffer is untouched.
+              onClick={() => setLines([])}
+            >
+              Clear view
+            </Button>
+          )}
+        </div>
+        {open && (
+          <pre
+            ref={consoleRef}
+            onScroll={handleScroll}
+            className="m-0 h-64 overflow-auto whitespace-pre-wrap break-words rounded-b-lg border-t border-border bg-zinc-950 p-3 font-mono text-xs leading-normal text-zinc-200"
+          >
+            {lines.length === 0 ? (
+              <span className="italic text-zinc-500">
+                Waiting for engine output…
+              </span>
+            ) : (
+              lines.join('\n')
+            )}
+          </pre>
+        )}
+      </div>
+    </section>
+  );
+}

apps/fastvideo_studio/src/components/jobs/JobCard.tsx

@@ -142,7 +142,7 @@ export default function JobCard({ job, onJobUpdated }: JobCardProps) {
   return (
     <article
       className={cn(
-        'mb-3 flex cursor-pointer flex-col gap-2.5 rounded-lg border bg-background p-4 transition-colors last:mb-0',
+        'mb-1.5 flex cursor-pointer flex-col gap-1 rounded-lg border bg-background px-3 py-1.5 transition-colors last:mb-0',
         isSelected
           ? 'border-accent-blue bg-accent-blue/5'
           : 'border-border hover:border-muted-foreground/40',
@@ -152,20 +152,16 @@ export default function JobCard({ job, onJobUpdated }: JobCardProps) {
         type="button"
         aria-pressed={isSelected}
         onClick={handleSelectJob}
-        className="flex w-full flex-col gap-2.5 rounded-md text-left"
+        className="flex w-full min-w-0 flex-col gap-1 rounded-md text-left"
       >
-        <span className="flex flex-wrap items-center justify-between gap-2">
-          <span className="text-[0.95rem] font-semibold text-foreground">
-            {job.model_id}
-          </span>
-          <Badge variant={BADGE_VARIANTS[job.status] ?? 'secondary'}>
-            {job.status}
-          </Badge>
+        <span className="flex w-full min-w-0 items-center gap-2">
+        <span className="shrink-0 text-sm font-semibold text-foreground">
+          {job.model_id}
         </span>
-        <span className="max-w-full overflow-hidden text-ellipsis whitespace-nowrap text-sm text-muted-foreground">
-          {job.prompt}
-        </span>
-        <span className="flex flex-wrap items-center gap-4 text-xs text-muted-foreground">
+        <Badge variant={BADGE_VARIANTS[job.status] ?? 'secondary'}>
+          {job.status}
+        </Badge>
+        <span className="ml-auto flex shrink-0 items-center gap-3 text-xs text-muted-foreground">
           {job.job_type === 'inference' ? (
             <>
               <span>{job.num_frames} frames</span>
@@ -183,6 +179,10 @@ export default function JobCard({ job, onJobUpdated }: JobCardProps) {
             </span>
           )}
         </span>
+        </span>
+        <span className="w-full whitespace-pre-wrap break-words text-xs text-muted-foreground">
+          {job.prompt}
+        </span>
       </button>
       <div className="flex flex-wrap items-center gap-1.5">
         {job.status === 'running' ? (
@@ -190,7 +190,7 @@ export default function JobCard({ job, onJobUpdated }: JobCardProps) {
             size="sm"
             onClick={handleStop}
             disabled={isLoading}
-            className="border-transparent bg-amber-500 text-black shadow-md hover:bg-amber-400"
+            className="h-6 px-2 text-xs border-transparent bg-amber-500 text-black shadow-md hover:bg-amber-400"
           >
             Stop
           </Button>
@@ -199,7 +199,7 @@ export default function JobCard({ job, onJobUpdated }: JobCardProps) {
             size="sm"
             onClick={handleStart}
             disabled={isLoading}
-            className="border-transparent bg-emerald-600 text-white shadow-md hover:bg-emerald-500"
+            className="h-6 px-2 text-xs border-transparent bg-emerald-600 text-white shadow-md hover:bg-emerald-500"
           >
             Restart
           </Button>
@@ -208,7 +208,7 @@ export default function JobCard({ job, onJobUpdated }: JobCardProps) {
             size="sm"
             onClick={handleStart}
             disabled={isLoading}
-            className="border-transparent bg-emerald-600 text-white shadow-md hover:bg-emerald-500"
+            className="h-6 px-2 text-xs border-transparent bg-emerald-600 text-white shadow-md hover:bg-emerald-500"
           >
             Start
           </Button>
@@ -222,6 +222,7 @@ export default function JobCard({ job, onJobUpdated }: JobCardProps) {
               onClick={handleDownloadVideo}
               disabled={isLoading}
               title="Download video"
+              className="h-6 px-2 text-xs"
             >
               Download Video
             </Button>
@@ -231,6 +232,7 @@ export default function JobCard({ job, onJobUpdated }: JobCardProps) {
           variant="destructive"
           onClick={handleDelete}
           disabled={isLoading}
+          className="h-6 px-2 text-xs"
         >
           Delete
         </Button>

apps/fastvideo_studio/src/components/jobs/JobDetailsSidebar.test.tsx

@@ -9,6 +9,7 @@ import { makeJob as makeBaseJob } from '@/test/factories';
 vi.mock('@/lib/api', () => ({
   getJobLogs: vi.fn(),
   downloadJobLog: vi.fn(),
+  getJobVideoUrl: (id: string) => `http://test.local/api/jobs/${id}/video`,
 }));
 
 const makeJob = (overrides: Partial<Job> = {}): Job =>
@@ -45,6 +46,43 @@ describe('JobDetailsSidebar', () => {
     expect(onWidthChange).toHaveBeenCalledWith(0);
   });
 
+  it('plays completed inference output inline; running jobs get no player', async () => {
+    vi.mocked(getJobLogs).mockResolvedValue({
+      lines: [],
+      total: 0,
+      progress: 0,
+      progress_msg: '',
+      phase: '',
+    });
+
+    const { rerender } = render(
+      <JobDetailsSidebar
+        job={makeJob({
+          status: 'completed',
+          output_path: '/outputs/job-1.mp4',
+          prompt: 'a cat surfing a wave',
+        })}
+        onClose={vi.fn()}
+      />,
+    );
+
+    const video = screen.getByLabelText('Generated video: a cat surfing a wave');
+    expect(video.tagName).toBe('VIDEO');
+    expect(video).toHaveAttribute('controls');
+    expect(video).toHaveAttribute(
+      'src',
+      'http://test.local/api/jobs/job-1/video',
+    );
+
+    rerender(
+      <JobDetailsSidebar
+        job={makeJob({ status: 'running', output_path: null })}
+        onClose={vi.fn()}
+      />,
+    );
+    expect(screen.queryByLabelText(/Generated video/)).not.toBeInTheDocument();
+  });
+
   it('renders log lines streamed from the job log poll', async () => {
     vi.mocked(getJobLogs).mockResolvedValue({
       lines: ['boot sequence started', 'loading model weights'],

apps/fastvideo_studio/src/components/jobs/JobDetailsSidebar.tsx

@@ -6,7 +6,7 @@ import { X } from 'lucide-react';
 import { Button } from '@/components/ui/button';
 import { useDrawerFocus } from '@/hooks/useDrawerFocus';
 import { useResizable } from '@/hooks/useResizable';
-import { downloadJobLog, getJobLogs } from '@/lib/api';
+import { downloadJobLog, getJobLogs, getJobVideoUrl } from '@/lib/api';
 import type { Job } from '@/lib/types';
 import { cn, downloadBlob } from '@/lib/utils';
 
@@ -180,6 +180,41 @@ export default function JobDetailsSidebar({
         </div>
       </div>
 
+      {job.status === 'completed' &&
+        job.output_path &&
+        (job.job_type === 'inference' || !job.job_type) && (
+          <div className="border-b border-border px-5 py-4">
+            <span className="mb-2 block text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+              Output
+            </span>
+            {job.output_path.toLowerCase().endsWith('.png') ? (
+              // eslint-disable-next-line @next/next/no-img-element
+              <img
+                src={getJobVideoUrl(job.id)}
+                alt={
+                  job.prompt
+                    ? `Generated image: ${job.prompt}`
+                    : 'Generated image'
+                }
+                className="block w-full rounded-lg border border-border bg-background object-contain"
+              />
+            ) : (
+              <video
+                src={getJobVideoUrl(job.id)}
+                aria-label={
+                  job.prompt
+                    ? `Generated video: ${job.prompt}`
+                    : 'Generated video'
+                }
+                controls
+                playsInline
+                preload="metadata"
+                className="block max-h-80 w-full rounded-lg border border-border bg-background object-contain"
+              />
+            )}
+          </div>
+        )}
+
       <div className="flex min-h-0 flex-1 flex-col px-5 py-4">
         <div className="mb-2 flex items-center justify-between">
           <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">

apps/fastvideo_studio/src/components/jobs/WarmModelsPanel.test.tsx

@@ -0,0 +1,188 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import WarmModelsPanel from './WarmModelsPanel';
+import {
+  getModels,
+  listGenerators,
+  preloadGenerator,
+  unloadGenerator,
+  type GeneratorInfo,
+} from '@/lib/api';
+import { DEFAULT_OPTIONS } from '@/lib/defaultOptions';
+import { defaultOptionsStore } from '@/stores/defaultOptions';
+import { toast } from 'sonner';
+
+vi.mock('@/lib/api', () => ({
+  getModels: vi.fn(),
+  listGenerators: vi.fn(),
+  preloadGenerator: vi.fn(),
+  unloadGenerator: vi.fn(),
+  getSettings: vi.fn(),
+  updateSettings: vi.fn(),
+}));
+
+vi.mock('sonner', () => ({
+  toast: { error: vi.fn() },
+}));
+
+const makeGenerator = (
+  overrides: Partial<GeneratorInfo> = {},
+): GeneratorInfo => ({
+  state: 'ready',
+  model_id: 'Wan-AI/Wan2.1-T2V-1.3B-Diffusers',
+  workload_type: 't2v',
+  num_gpus: 1,
+  dit_cpu_offload: false,
+  text_encoder_cpu_offload: false,
+  vae_cpu_offload: false,
+  image_encoder_cpu_offload: false,
+  use_fsdp_inference: false,
+  enable_torch_compile: false,
+  vsa_sparsity: 0,
+  tp_size: -1,
+  sp_size: -1,
+  error: null,
+  ...overrides,
+});
+
+beforeEach(() => {
+  // Reset the shared options store to a known baseline for test isolation.
+  defaultOptionsStore.set({ options: DEFAULT_OPTIONS });
+  vi.mocked(getModels).mockResolvedValue([
+    { id: 'Wan-AI/Wan2.1-T2V-1.3B-Diffusers', label: 'Wan2.1 T2V 1.3B' },
+  ]);
+  vi.mocked(listGenerators).mockResolvedValue([]);
+  vi.mocked(preloadGenerator).mockResolvedValue(
+    makeGenerator({ state: 'loading' }),
+  );
+  vi.mocked(unloadGenerator).mockResolvedValue(undefined);
+});
+
+describe('WarmModelsPanel', () => {
+  it('shows the empty slot when no model is loaded', async () => {
+    render(<WarmModelsPanel />);
+
+    expect(await screen.findByText('No model loaded')).toBeInTheDocument();
+    expect(
+      screen.queryByRole('button', { name: 'Unload' }),
+    ).not.toBeInTheDocument();
+  });
+
+  it('renders the resident slot with its state and config summary', async () => {
+    vi.mocked(listGenerators).mockResolvedValue([
+      makeGenerator({ num_gpus: 8, enable_torch_compile: true }),
+    ]);
+    render(<WarmModelsPanel />);
+
+    // Model label: last path segment with dashes/underscores as spaces.
+    expect(
+      await screen.findByText('Wan2.1 T2V 1.3B Diffusers'),
+    ).toBeInTheDocument();
+    expect(screen.getByText('ready')).toBeInTheDocument();
+    expect(screen.getByText('8 GPU · compile')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Unload' })).toBeInTheDocument();
+  });
+
+  it('disables loading a new model while a load is in flight', async () => {
+    vi.mocked(listGenerators).mockResolvedValue([
+      makeGenerator({ state: 'loading' }),
+    ]);
+    render(<WarmModelsPanel />);
+
+    expect(await screen.findByText('loading')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Load model' })).toBeDisabled();
+    expect(
+      screen.queryByRole('button', { name: 'Unload' }),
+    ).not.toBeInTheDocument();
+  });
+
+  it('shows the error on a failed slot and keeps retry enabled', async () => {
+    vi.mocked(listGenerators).mockResolvedValue([
+      makeGenerator({ state: 'failed', error: 'CUDA out of memory' }),
+    ]);
+    render(<WarmModelsPanel />);
+
+    expect(await screen.findByText('failed')).toHaveAttribute(
+      'title',
+      'CUDA out of memory',
+    );
+    await waitFor(() =>
+      expect(screen.getByRole('button', { name: 'Load model' })).toBeEnabled(),
+    );
+  });
+
+  it('labels the load button as a swap when a different model is resident', async () => {
+    vi.mocked(listGenerators).mockResolvedValue([
+      makeGenerator({ model_id: 'FastVideo/FastHunyuan-diffusers' }),
+    ]);
+    render(<WarmModelsPanel />);
+
+    expect(
+      await screen.findByRole('button', { name: 'Load (replaces current)' }),
+    ).toBeInTheDocument();
+  });
+
+  it('loads the selected model with the persisted default options', async () => {
+    defaultOptionsStore.set({
+      options: { ...DEFAULT_OPTIONS, numGpus: 4, enableTorchCompile: true },
+    });
+    const user = userEvent.setup();
+    render(<WarmModelsPanel />);
+
+    const button = await screen.findByRole('button', { name: 'Load model' });
+    await waitFor(() => expect(button).toBeEnabled());
+    await user.click(button);
+
+    await waitFor(() =>
+      expect(preloadGenerator).toHaveBeenCalledWith({
+        model_id: 'Wan-AI/Wan2.1-T2V-1.3B-Diffusers',
+        workload_type: 't2v',
+        num_gpus: 4,
+        dit_cpu_offload: false,
+        text_encoder_cpu_offload: false,
+        vae_cpu_offload: false,
+        image_encoder_cpu_offload: false,
+        use_fsdp_inference: false,
+        enable_torch_compile: true,
+        vsa_sparsity: 0,
+        tp_size: -1,
+        sp_size: -1,
+      }),
+    );
+    // The panel refetches so the new "loading" slot appears promptly.
+    await waitFor(() => expect(listGenerators).toHaveBeenCalledTimes(2));
+  });
+
+  it('surfaces the backend detail when a load is rejected', async () => {
+    vi.mocked(preloadGenerator).mockRejectedValue(
+      new Error('a model load is already in progress'),
+    );
+    const user = userEvent.setup();
+    render(<WarmModelsPanel />);
+
+    const button = await screen.findByRole('button', { name: 'Load model' });
+    await waitFor(() => expect(button).toBeEnabled());
+    await user.click(button);
+
+    await waitFor(() =>
+      expect(toast.error).toHaveBeenCalledWith('Model was not loaded', {
+        description: 'a model load is already in progress',
+      }),
+    );
+  });
+
+  it('unloads the resident model with no payload', async () => {
+    vi.mocked(listGenerators).mockResolvedValue([makeGenerator()]);
+    const user = userEvent.setup();
+    render(<WarmModelsPanel />);
+
+    await user.click(await screen.findByRole('button', { name: 'Unload' }));
+
+    await waitFor(() => expect(unloadGenerator).toHaveBeenCalledTimes(1));
+    expect(vi.mocked(unloadGenerator).mock.calls[0]).toEqual([]);
+    // The slot refreshes after the unload succeeds.
+    await waitFor(() => expect(listGenerators).toHaveBeenCalledTimes(2));
+  });
+});

apps/fastvideo_studio/src/components/jobs/WarmModelsPanel.tsx

@@ -0,0 +1,237 @@
+'use client';
+
+import * as React from 'react';
+import { toast } from 'sonner';
+
+import { Badge, type BadgeProps } from '@/components/ui/badge';
+import { Button } from '@/components/ui/button';
+import { NativeSelect } from '@/components/ui/native-select';
+import { useStore } from '@/hooks/useStore';
+import {
+  getModels,
+  listGenerators,
+  preloadGenerator,
+  unloadGenerator,
+  type GeneratorInfo,
+  type Model,
+} from '@/lib/api';
+import { getDefaultModelForWorkload } from '@/lib/defaultOptions';
+import { defaultOptionsStore } from '@/stores/defaultOptions';
+
+// Mirrors the backend's model_label(): readable label from an HF-style path.
+function modelLabel(modelId: string): string {
+  return (modelId.split('/').pop() ?? modelId).replace(/[-_]/g, ' ');
+}
+
+// Compact summary of only the non-default engine bits, e.g. "8 GPU · compile".
+function configSummary(gen: GeneratorInfo): string {
+  const parts: string[] = [];
+  if (gen.num_gpus !== 1) parts.push(`${gen.num_gpus} GPU`);
+  if (gen.sp_size !== -1) parts.push(`SP ${gen.sp_size}`);
+  if (gen.tp_size !== -1) parts.push(`TP ${gen.tp_size}`);
+  if (gen.dit_cpu_offload) parts.push('DiT offload');
+  if (gen.text_encoder_cpu_offload) parts.push('TE offload');
+  if (gen.vae_cpu_offload) parts.push('VAE offload');
+  if (gen.image_encoder_cpu_offload) parts.push('image enc offload');
+  if (gen.use_fsdp_inference) parts.push('FSDP');
+  if (gen.enable_torch_compile) parts.push('compile');
+  if (gen.vsa_sparsity > 0) parts.push(`VSA ${gen.vsa_sparsity.toFixed(2)}`);
+  return parts.join(' · ');
+}
+
+const STATE_VARIANTS: Record<GeneratorInfo['state'], BadgeProps['variant']> = {
+  ready: 'success',
+  loading: 'warning',
+  failed: 'destructive',
+};
+
+/**
+ * Utility strip for the engine's single model slot: shows the resident model
+ * (ready/loading/failed), loads the selected model using the persisted
+ * default job options (replacing whatever is resident), and unloads it.
+ */
+export default function WarmModelsPanel() {
+  const { options } = useStore(defaultOptionsStore);
+
+  const [slot, setSlot] = React.useState<GeneratorInfo | null>(null);
+  const [models, setModels] = React.useState<Model[]>([]);
+  const [modelId, setModelId] = React.useState('');
+  const [isBusy, setIsBusy] = React.useState(false);
+
+  const fetchSlot = React.useCallback(async () => {
+    try {
+      const list = await listGenerators();
+      setSlot(list[0] ?? null);
+    } catch (e) {
+      console.error('Failed to fetch generators:', e);
+    }
+  }, []);
+
+  React.useEffect(() => {
+    fetchSlot();
+  }, [fetchSlot]);
+
+  // Poll every 5s while a load is in flight; stop otherwise.
+  const isLoading = slot?.state === 'loading';
+  React.useEffect(() => {
+    if (!isLoading) return;
+    const interval = setInterval(fetchSlot, 5000);
+    return () => clearInterval(interval);
+  }, [isLoading, fetchSlot]);
+
+  // Same model catalogue (and default selection) as the create-job modal.
+  React.useEffect(() => {
+    getModels('t2v')
+      .then((list) => {
+        setModels(list);
+        const defaultId = getDefaultModelForWorkload(
+          defaultOptionsStore.get().options,
+          't2v',
+        );
+        setModelId(
+          list.some((m) => m.id === defaultId)
+            ? defaultId
+            : (list[0]?.id ?? ''),
+        );
+      })
+      .catch((e) => console.error('Failed to load models:', e));
+  }, []);
+
+  async function handleLoad() {
+    if (!modelId || isBusy || isLoading) return;
+    setIsBusy(true);
+    try {
+      await preloadGenerator({
+        model_id: modelId,
+        workload_type: 't2v',
+        num_gpus: options.numGpus,
+        dit_cpu_offload: options.ditCpuOffload,
+        text_encoder_cpu_offload: options.textEncoderCpuOffload,
+        vae_cpu_offload: options.vaeCpuOffload,
+        image_encoder_cpu_offload: options.imageEncoderCpuOffload,
+        use_fsdp_inference: options.useFsdpInference,
+        enable_torch_compile: options.enableTorchCompile,
+        vsa_sparsity: options.vsaSparsity,
+        tp_size: options.tpSize,
+        sp_size: options.spSize,
+      });
+      await fetchSlot();
+    } catch (err) {
+      console.error('Failed to load model:', err);
+      toast.error('Model was not loaded', {
+        description:
+          err instanceof Error
+            ? err.message
+            : 'Check the Studio API, then retry.',
+      });
+    } finally {
+      setIsBusy(false);
+    }
+  }
+
+  async function handleUnload() {
+    if (isBusy) return;
+    setIsBusy(true);
+    try {
+      await unloadGenerator();
+      await fetchSlot();
+    } catch (err) {
+      console.error('Failed to unload model:', err);
+      toast.error('Model was not unloaded', {
+        description:
+          err instanceof Error
+            ? err.message
+            : 'Check the Studio API, then retry.',
+      });
+    } finally {
+      setIsBusy(false);
+    }
+  }
+
+  // Loading a model always replaces the resident one — say so on the button.
+  const replaces = slot !== null && !!modelId && slot.model_id !== modelId;
+
+  return (
+    <section
+      aria-label="Warm models"
+      className="mx-auto w-full max-w-[850px] px-10 pt-6"
+    >
+      <div className="flex flex-col gap-3 rounded-lg border border-border bg-background p-4">
+        <div className="flex flex-wrap items-center gap-2">
+          <h2 className="mr-auto text-sm font-semibold text-foreground">
+            Warm Model
+          </h2>
+          <label htmlFor="warm-model-select" className="sr-only">
+            Model to load
+          </label>
+          <NativeSelect
+            id="warm-model-select"
+            value={modelId}
+            onChange={(e) => setModelId(e.target.value)}
+            disabled={isBusy || models.length === 0}
+            className="h-9 w-auto max-w-64 rounded-lg"
+          >
+            <option value="" disabled>
+              {models.length === 0 ? 'Loading models…' : 'Select a model…'}
+            </option>
+            {models.map((model) => (
+              <option key={model.id} value={model.id}>
+                {model.label}
+              </option>
+            ))}
+          </NativeSelect>
+          <Button
+            size="sm"
+            onClick={handleLoad}
+            disabled={isBusy || !modelId || isLoading}
+          >
+            {replaces ? 'Load (replaces current)' : 'Load model'}
+          </Button>
+        </div>
+        <p className="text-xs text-muted-foreground">
+          One model at a time stays resident in GPU memory so jobs skip the
+          load wait; loading a new one replaces it (uses your default job
+          options).
+        </p>
+        <div className="flex min-h-8 flex-wrap items-center gap-2">
+          {slot ? (
+            <>
+              <Badge
+                variant={STATE_VARIANTS[slot.state]}
+                className={
+                  slot.state === 'loading' ? 'animate-pulse' : undefined
+                }
+                title={
+                  slot.state === 'failed' ? (slot.error ?? undefined) : undefined
+                }
+              >
+                {slot.state}
+              </Badge>
+              <span className="text-sm font-medium text-foreground">
+                {modelLabel(slot.model_id)}
+              </span>
+              <span className="text-xs text-muted-foreground">
+                {configSummary(slot)}
+              </span>
+              {slot.state === 'ready' && (
+                <Button
+                  size="sm"
+                  variant="outline"
+                  className="ml-auto"
+                  onClick={handleUnload}
+                  disabled={isBusy}
+                >
+                  Unload
+                </Button>
+              )}
+            </>
+          ) : (
+            <span className="text-sm text-muted-foreground">
+              No model loaded
+            </span>
+          )}
+        </div>
+      </div>
+    </section>
+  );
+}

apps/fastvideo_studio/src/components/shell/Header.tsx

@@ -8,9 +8,9 @@ import { Button } from '@/components/ui/button';
 import { ThemeToggle } from '@/components/ui/theme-toggle';
 
 const TAB_TITLES: Record<string, string> = {
-  '/inference': 'Jobs',
-  '/finetuning': 'Jobs',
-  '/distillation': 'Jobs',
+  '/inference': 'Studio',
+  '/finetuning': 'Studio',
+  '/distillation': 'Studio',
   '/datasets': 'Datasets',
   '/gallery': 'Gallery',
   '/gpus': 'GPUs',

apps/fastvideo_studio/src/components/shell/PrimarySidebar.tsx

@@ -108,7 +108,7 @@ export default function PrimarySidebar({
                 isJobsActive && TAB_ACTIVE,
               )}
             >
-              <span>Jobs</span>
+              <span>Studio</span>
               <svg
                 viewBox="0 0 24 24"
                 fill="none"

apps/fastvideo_studio/src/lib/api.ts

@@ -202,6 +202,33 @@ export async function getModels(workloadType?: string): Promise<Model[]> {
 	return response.json();
 }
 
+/**
+ * A model's recommended sampling settings. Keys the backend has no value
+ * for are absent; the UI leaves those form fields untouched.
+ */
+export interface ModelPresets {
+	height?: number;
+	width?: number;
+	num_frames?: number;
+	fps?: number;
+	num_inference_steps?: number;
+	guidance_scale?: number;
+	guidance_rescale?: number;
+	negative_prompt?: string;
+	seed?: number;
+}
+
+export async function getModelPresets(modelId: string): Promise<ModelPresets> {
+	const baseApiUrl = getApiBaseUrl();
+	const response = await fetch(
+		`${baseApiUrl}/models/presets?model_id=${encodeURIComponent(modelId)}`,
+	);
+	if (!response.ok) {
+		throw new Error("Failed to fetch model presets");
+	}
+	return response.json();
+}
+
 export async function getGpus(): Promise<GpuSnapshot> {
 	const baseApiUrl = getApiBaseUrl();
 	const response = await fetch(`${baseApiUrl}/gpus`);
@@ -319,6 +346,109 @@ export async function downloadJobVideo(id: string): Promise<Blob> {
 	return response.blob();
 }
 
+// --- Generators (warm models) ---
+
+/**
+ * Engine subset of CreateJobRequest that identifies one resident generator.
+ * Mirrors the backend's GeneratorRequest defaults.
+ */
+export interface GeneratorRequest {
+	model_id: string;
+	workload_type?: string;
+	num_gpus?: number;
+	dit_cpu_offload?: boolean;
+	text_encoder_cpu_offload?: boolean;
+	vae_cpu_offload?: boolean;
+	image_encoder_cpu_offload?: boolean;
+	use_fsdp_inference?: boolean;
+	enable_torch_compile?: boolean;
+	vsa_sparsity?: number;
+	tp_size?: number;
+	sp_size?: number;
+}
+
+export interface GeneratorInfo {
+	state: "ready" | "loading" | "failed";
+	model_id: string;
+	workload_type: string;
+	num_gpus: number;
+	dit_cpu_offload: boolean;
+	text_encoder_cpu_offload: boolean;
+	vae_cpu_offload: boolean;
+	image_encoder_cpu_offload: boolean;
+	use_fsdp_inference: boolean;
+	enable_torch_compile: boolean;
+	vsa_sparsity: number;
+	tp_size: number;
+	sp_size: number;
+	error: string | null;
+	started_at?: number;
+}
+
+/** The single resident slot: [] when nothing is loaded, else one entry. */
+export async function listGenerators(): Promise<GeneratorInfo[]> {
+	const baseApiUrl = getApiBaseUrl();
+	const response = await fetch(`${baseApiUrl}/generators`);
+	if (!response.ok) {
+		throw new Error("Failed to fetch generators");
+	}
+	return response.json();
+}
+
+export async function preloadGenerator(
+	req: GeneratorRequest,
+): Promise<GeneratorInfo> {
+	const baseApiUrl = getApiBaseUrl();
+	const response = await fetch(`${baseApiUrl}/generators/preload`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify(req),
+	});
+	if (!response.ok) {
+		const error = await response
+			.json()
+			.catch(() => ({ detail: "Failed to preload model" }));
+		throw new Error(error.detail || "Failed to preload model");
+	}
+	return response.json();
+}
+
+/** Unload the single resident generator (no body — there is only one slot). */
+export async function unloadGenerator(): Promise<void> {
+	const baseApiUrl = getApiBaseUrl();
+	const response = await fetch(`${baseApiUrl}/generators/unload`, {
+		method: "POST",
+	});
+	if (!response.ok) {
+		const error = await response
+			.json()
+			.catch(() => ({ detail: "Failed to unload model" }));
+		throw new Error(error.detail || "Failed to unload model");
+	}
+}
+
+// --- Engine logs ---
+
+export interface EngineLogs {
+	lines: string[];
+	total: number;
+}
+
+/**
+ * Incremental tail of the engine's stdout/stderr. Poll with
+ * `after=<total from the previous response>`.
+ */
+export async function getEngineLogs(after: number = 0): Promise<EngineLogs> {
+	const baseApiUrl = getApiBaseUrl();
+	const response = await fetch(`${baseApiUrl}/engine/logs?after=${after}`);
+	if (!response.ok) {
+		throw new Error("Failed to fetch engine logs");
+	}
+	return response.json();
+}
+
 // --- Datasets ---
 
 export interface Dataset {
@@ -418,3 +548,35 @@ export function getDatasetMediaUrl(
 	const baseApiUrl = getApiBaseUrl();
 	return `${baseApiUrl}/datasets/${datasetId}/media/${encodeURIComponent(fileName)}`;
 }
+
+// --- Cluster ---
+
+/** Per-GPU telemetry within a cluster node (same shape as GpuInfo). */
+export type ClusterGpu = GpuInfo;
+
+export interface ClusterNode {
+	hostname: string;
+	ip: string | null;
+	is_this_host: boolean;
+	cpus: number | null;
+	ray_gpus: number | null;
+	available: boolean;
+	error: string | null;
+	gpus: ClusterGpu[];
+}
+
+export interface ClusterSnapshot {
+	mode: "ray" | "local";
+	nodes: ClusterNode[];
+	resources: { gpus_total: number; gpus_available: number } | null;
+	error: string | null;
+}
+
+export async function getClusterStatus(): Promise<ClusterSnapshot> {
+	const baseApiUrl = getApiBaseUrl();
+	const response = await fetch(`${baseApiUrl}/cluster`);
+	if (!response.ok) {
+		throw new Error("Failed to fetch cluster status");
+	}
+	return response.json();
+}

apps/fastvideo_studio/tests/test_generator_cache.py

@@ -0,0 +1,273 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Tests for the single-slot resident generator: preload, list, unload.
+
+Exactly one VideoGenerator lives in memory. One load at a time; loading a new
+config always releases the old instance; unload deletes it. The generator is
+faked at the ``_create_generator_into_slot``/VideoGenerator boundary.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+
+from fastvideo_studio.job_runner import JobRunner, JobStatus
+
+
+class _FakeGenerator:
+    def __init__(self) -> None:
+        self.shutdown_calls = 0
+
+    def shutdown(self) -> None:
+        self.shutdown_calls += 1
+
+
+@pytest.fixture()
+def runner():
+    r = JobRunner.__new__(JobRunner)  # skip __init__: no DB/Manager needed
+    r._jobs = {}
+    r._jobs_lock = threading.Lock()
+    r._generator = None
+    r._generator_config = None
+    r._generator_state = "empty"
+    r._generator_error = None
+    r._generator_lock = threading.Lock()
+    r._load_lock = threading.Lock()
+    r._worker_log_queue = None  # no Manager in unit tests
+    import queue as _queue
+    r._loader_queue = _queue.Queue()
+    threading.Thread(target=r._loader_loop, daemon=True).start()
+    return r
+
+
+def _install_fake_loader(runner, monkeypatch, made: list | None = None,
+                         gate: threading.Event | None = None,
+                         fail: str | None = None):
+    """Replace the VideoGenerator load inside _create_generator_into_slot."""
+    import fastvideo_studio.job_runner as jr
+
+    class _FakeVG:
+        @staticmethod
+        def from_pretrained(model_path, **kwargs):
+            if gate is not None:
+                assert gate.wait(5), "test gate never opened"
+            if fail is not None:
+                raise RuntimeError(fail)
+            gen = _FakeGenerator()
+            if made is not None:
+                made.append((model_path, gen))
+            return gen
+
+    monkeypatch.setitem(__import__("sys").modules, "fastvideo",
+                        SimpleNamespace(VideoGenerator=_FakeVG))
+    return jr
+
+
+def _wait_state(runner, state, timeout=5.0):
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        with runner._generator_lock:
+            if runner._generator_state == state:
+                return runner._slot_entry()
+        time.sleep(0.02)
+    raise AssertionError(f"never reached state {state}: {runner._generator_state}")
+
+
+def test_preload_then_ready_then_idempotent(runner, monkeypatch):
+    made = []
+    _install_fake_loader(runner, monkeypatch, made=made)
+
+    entry = runner.preload_generator(model_id="org/a", workload_type="t2v", num_gpus=8)
+    assert entry["state"] in ("loading", "ready")
+    _wait_state(runner, "ready")
+
+    again = runner.preload_generator(model_id="org/a", workload_type="t2v", num_gpus=8)
+    assert again["state"] == "ready"
+    assert len(made) == 1  # same config never reloads
+
+
+def test_only_one_load_at_a_time(runner, monkeypatch):
+    gate = threading.Event()
+    _install_fake_loader(runner, monkeypatch, gate=gate)
+
+    runner.preload_generator(model_id="org/a", workload_type="t2v", num_gpus=8)
+    with pytest.raises(RuntimeError, match="already in progress"):
+        runner.preload_generator(model_id="org/b", workload_type="t2v", num_gpus=8)
+    gate.set()
+    _wait_state(runner, "ready")
+
+
+def test_new_config_always_releases_old_instance(runner, monkeypatch):
+    made = []
+    _install_fake_loader(runner, monkeypatch, made=made)
+
+    runner.preload_generator(model_id="org/a", workload_type="t2v", num_gpus=8)
+    _wait_state(runner, "ready")
+    first = made[0][1]
+
+    runner.preload_generator(model_id="org/b", workload_type="t2v", num_gpus=8)
+    _wait_state(runner, "ready")
+    assert first.shutdown_calls == 1  # old instance released, not stacked
+    assert [m[0] for m in made] == ["org/a", "org/b"]
+    assert len(runner.list_generators()) == 1
+    assert runner.list_generators()[0]["model_id"] == "org/b"
+
+
+def test_failed_load_reports_error_and_allows_retry(runner, monkeypatch):
+    _install_fake_loader(runner, monkeypatch, fail="no CUDA on this box")
+    runner.preload_generator(model_id="org/broken", workload_type="t2v", num_gpus=1)
+    failed = _wait_state(runner, "failed")
+    assert "no CUDA" in failed["error"]
+
+    # retry after failure must be accepted (this was the reported bug)
+    made = []
+    _install_fake_loader(runner, monkeypatch, made=made)
+    runner.preload_generator(model_id="org/broken", workload_type="t2v", num_gpus=1)
+    _wait_state(runner, "ready")
+    assert len(made) == 1
+
+
+def test_unload_deletes_instance(runner, monkeypatch):
+    made = []
+    _install_fake_loader(runner, monkeypatch, made=made)
+    runner.preload_generator(model_id="org/a", workload_type="t2v", num_gpus=8)
+    _wait_state(runner, "ready")
+
+    assert runner.unload_generator() is True
+    assert made[0][1].shutdown_calls == 1
+    assert runner.list_generators() == []
+    assert runner._generator is None
+    assert runner.unload_generator() is False  # nothing resident
+
+
+def test_unload_refuses_while_inference_job_runs(runner, monkeypatch):
+    made = []
+    _install_fake_loader(runner, monkeypatch, made=made)
+    runner.preload_generator(model_id="org/a", workload_type="t2v", num_gpus=8)
+    _wait_state(runner, "ready")
+    runner._jobs["j1"] = SimpleNamespace(id="j1", status=JobStatus.RUNNING, job_type="inference")
+
+    with pytest.raises(RuntimeError, match="j1"):
+        runner.unload_generator()
+    assert made[0][1].shutdown_calls == 0
+
+    runner._jobs["j1"].job_type = "finetune"  # training doesn't block
+    assert runner.unload_generator() is True
+
+
+def test_job_waits_for_matching_preload(runner, monkeypatch):
+    gate = threading.Event()
+    made = []
+    _install_fake_loader(runner, monkeypatch, made=made, gate=gate)
+
+    runner.preload_generator(model_id="org/a", workload_type="t2v", num_gpus=8)
+    got = []
+    t = threading.Thread(
+        target=lambda: got.append(
+            runner._get_or_create_generator("org/a", "t2v", 8)),
+        daemon=True)
+    t.start()
+    time.sleep(0.2)
+    assert not got  # job blocked on the in-flight load
+    gate.set()
+    t.join(5)
+    assert got and got[0] is made[0][1]
+    assert len(made) == 1  # the job reused the preloaded instance
+
+
+def test_job_with_different_config_replaces_slot(runner, monkeypatch):
+    made = []
+    _install_fake_loader(runner, monkeypatch, made=made)
+    runner.preload_generator(model_id="org/a", workload_type="t2v", num_gpus=8)
+    _wait_state(runner, "ready")
+
+    gen = runner._get_or_create_generator("org/b", "t2v", 4)
+    assert gen is made[1][1]
+    assert made[0][1].shutdown_calls == 1  # old released before new load
+    assert runner.list_generators()[0]["model_id"] == "org/b"
+
+
+def test_job_during_replace_never_sees_half_replaced_slot(runner, monkeypatch):
+    """Regression: user restarted a stale 1-gpu job while an 8-gpu generator
+    was resident; the replace nulled the generator with state still 'ready',
+    and the next (correct) job grabbed None -> AttributeError on
+    generate_video. All transitions now serialize under the load lock."""
+    made = []
+    gate = threading.Event()
+    _install_fake_loader(runner, monkeypatch, made=made)
+    runner.preload_generator(model_id="org/h3", workload_type="t2v", num_gpus=8)
+    _wait_state(runner, "ready")
+
+    _install_fake_loader(runner, monkeypatch, made=made, gate=gate)
+    results: dict[str, Any] = {}
+
+    def job_a():  # stale job: mismatching config triggers a slow replace
+        results["a"] = runner._get_or_create_generator("org/h3", "t2v", 1)
+
+    def job_b():  # correct job arriving mid-replace
+        time.sleep(0.3)
+        results["b"] = runner._get_or_create_generator("org/h3", "t2v", 8)
+
+    ta = threading.Thread(target=job_a, daemon=True)
+    tb = threading.Thread(target=job_b, daemon=True)
+    ta.start(); tb.start()
+    time.sleep(0.6)
+    gate.set()
+    ta.join(10); tb.join(10)
+
+    assert results["a"] is not None and hasattr(results["a"], "shutdown")
+    assert results["b"] is not None and hasattr(results["b"], "shutdown")
+    # b arrived second, so the slot ends at b's 8-gpu config
+    assert runner.list_generators()[0]["num_gpus"] == 8
+
+
+def test_config_dict_matches_request_defaults(runner):
+    """GeneratorRequest defaults and CreateJobRequest defaults must resolve to
+    the same slot config — else preloading never matches the job."""
+    from fastvideo_studio.models import CreateJobRequest, GeneratorRequest
+
+    job = CreateJobRequest(model_id="m", prompt="p").model_dump()
+    pre = GeneratorRequest(model_id="m").model_dump()
+    assert runner._generator_config_dict(**pre) == runner._generator_config_dict(
+        **{k: job[k] for k in pre})
+
+
+def test_engine_log_buffer_incremental_tail():
+    from fastvideo_studio.server import _EngineLogBuffer
+
+    buf = _EngineLogBuffer(maxlen=3)
+    buf.write("a\nb\n")
+    buf.write("c")          # partial line: not visible yet
+    lines, total = buf.get_lines(0)
+    assert lines == ["a", "b"] and total == 2
+    buf.write("!\nd\ne\n")  # completes "c!", then overflows the ring
+    lines, total = buf.get_lines(total)
+    assert lines == ["c!", "d", "e"] and total == 5
+    # reader far behind: dropped lines are skipped, no crash
+    lines, _ = buf.get_lines(0)
+    assert lines == ["c!", "d", "e"]
+
+
+def test_engine_feed_drives_job_progress(runner):
+    from fastvideo_studio.job_runner import Job
+
+    job = Job(id="j-prog", model_id="m", prompt="p")
+    runner._active_inference_job = job
+    # ray wraps relayed lines in ANSI color codes — the bridge must strip them
+    runner.feed_engine_line("\x1b[36m(RayWorkerWrapper pid=123, ip=10.0.0.2)\x1b[0m denoising:  40%|████      | 20/50 [00:30<00:45,  1.5s/it]")
+    assert job._log_buf.progress == 40.0
+    assert job._log_buf.progress_msg == "20/50 steps"
+
+    # driver-side lines (no ray prefix) are NOT double-fed
+    before = job._log_buf.get_lines()[1]
+    runner.feed_engine_line("INFO 08-07 [video_generator.py] driver line")
+    assert job._log_buf.get_lines()[1] == before
+
+    # no active job: no-op
+    runner._active_inference_job = None
+    runner.feed_engine_line("(RayWorkerWrapper pid=123)  90%|████| 45/50")
+    assert job._log_buf.progress == 40.0

apps/fastvideo_studio/tests/test_gpu.py

@@ -74,8 +74,10 @@ def test_snapshot_shapes_devices(monkeypatch: pytest.MonkeyPatch) -> None:
     }
 
 
-def test_snapshot_tolerates_missing_sensors(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setitem(sys.modules, "pynvml", _make_fake_pynvml(broken_sensors=True))
+def test_snapshot_tolerates_missing_sensors(
+        monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setitem(sys.modules, "pynvml",
+                        _make_fake_pynvml(broken_sensors=True))
     snap = gpu_mod.get_gpu_snapshot()
     assert snap["available"] is True
     g = snap["gpus"][0]
@@ -84,7 +86,8 @@ def test_snapshot_tolerates_missing_sensors(monkeypatch: pytest.MonkeyPatch) ->
     assert g["power_limit_watts"] is None
 
 
-def test_snapshot_reports_nvml_failure(monkeypatch: pytest.MonkeyPatch) -> None:
+def test_snapshot_reports_nvml_failure(
+        monkeypatch: pytest.MonkeyPatch) -> None:
     fake = _make_fake_pynvml()
     fake.nvmlInit = lambda: (_ for _ in ()).throw(_NVMLError("driver gone"))
     monkeypatch.setitem(sys.modules, "pynvml", fake)

apps/fastvideo_studio/tests/test_training_config.py

@@ -130,7 +130,8 @@ def test_dmd_builds_three_role_models_and_method_knobs() -> None:
 
 
 def test_dmd_vsa_maps_to_training_vsa_sparsity() -> None:
-    config = build_training_config(_job("dmd_t2v", dmd_use_vsa=True, dmd_vsa_sparsity=0.9), "out")
+    config = build_training_config(
+        _job("dmd_t2v", dmd_use_vsa=True, dmd_vsa_sparsity=0.9), "out")
     assert config["training"]["vsa"]["sparsity"] == 0.9
 
 
@@ -160,27 +161,31 @@ def test_validation_callback_only_when_file_given() -> None:
     without = build_training_config(_job("full_t2v"), "out")
     assert "validation" not in without["callbacks"]
 
-    with_file = build_training_config(_job("full_t2v", validation_dataset_file="val.json"), "out")
+    with_file = build_training_config(
+        _job("full_t2v", validation_dataset_file="val.json"), "out")
     validation = with_file["callbacks"]["validation"]
     assert validation["dataset_file"] == "val.json"
     assert validation["pipeline_target"].endswith(".WanPipeline")
     assert validation["sampling_steps"] == [50]
 
-    dmd = build_training_config(_job("dmd_t2v", validation_dataset_file="val.json"), "out")
+    dmd = build_training_config(
+        _job("dmd_t2v", validation_dataset_file="val.json"), "out")
     validation = dmd["callbacks"]["validation"]
     assert validation["pipeline_target"].endswith(".WanDMDPipeline")
     assert validation["sampling_steps"] == [3]
     assert validation["sampling_timesteps"] == [1000, 757, 522]
 
     # KD/ODE-init has no sampling-based validation pipeline.
-    ode = build_training_config(_job("ode_init", validation_dataset_file="val.json"), "out")
+    ode = build_training_config(
+        _job("ode_init", validation_dataset_file="val.json"), "out")
     assert "validation" not in ode["callbacks"]
 
 
 def test_ltx2_models_are_rejected() -> None:
     assert is_ltx2_model("Lightricks/LTX-2-19B")
     with pytest.raises(ValueError, match="LTX-2 training is not supported"):
-        build_training_config(_job("full_t2v", model_id="Lightricks/LTX-2-19B"), "out")
+        build_training_config(
+            _job("full_t2v", model_id="Lightricks/LTX-2-19B"), "out")
 
 
 def test_unknown_workload_is_rejected() -> None:
@@ -190,7 +195,8 @@ def test_unknown_workload_is_rejected() -> None:
 
 def test_invalid_denoising_steps_are_rejected() -> None:
     with pytest.raises(ValueError, match="Invalid DMD denoising steps"):
-        build_training_config(_job("dmd_t2v", dmd_denoising_steps="1000,abc"), "out")
+        build_training_config(
+            _job("dmd_t2v", dmd_denoising_steps="1000,abc"), "out")
 
 
 def test_training_env_has_no_backend_override() -> None:
@@ -205,7 +211,8 @@ def test_workloads_match_frontend_job_config() -> None:
     (src/lib/jobConfig.ts) — drift means creatable-but-unrunnable jobs."""
     import re
 
-    job_config = (Path(__file__).resolve().parents[1] / "src" / "lib" / "jobConfig.ts").read_text(encoding="utf-8")
+    job_config = (Path(__file__).resolve().parents[1] / "src" / "lib" /
+                  "jobConfig.ts").read_text(encoding="utf-8")
     all_types = set(re.findall(r'type:\s*"([^"]+)"', job_config))
     inference_types = {"t2v", "i2v", "t2i"}
     assert inference_types <= all_types, "jobConfig.ts parse failed"

docker/Dockerfile

@@ -68,7 +68,7 @@ ARG FLASH_ATTN_WHEEL_RELEASE_ARM64=https://github.com/mjun0812/flash-attention-p
 # cutlass-4.4 `cute.core.ThrMma` API, which crashes on the cutlass-dsl 4.5 that
 # flashinfer/quack pull in. After the wheel install we overlay this cutlass-4.5-safe
 # upstream cute (flash-attn-4) so the image runs FA4 instead of the FA2 fallback.
-ARG FA4_CUTE_REF=14c377950125c70b7a9dabf9c561fca53715ac7d
+ARG FA4_CUTE_REF=82d6441eec5d4dfec120153db2c0145ae855a083
 
 # Provided automatically by BuildKit/buildx (e.g. "amd64" / "arm64") and used to
 # select the prebuilt flash-attn wheel. Empty under a plain `docker build` without
@@ -89,29 +89,11 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     zsh \
     vim \
     curl \
-    ffmpeg \
-    libgl1 \
-    libglib2.0-0 \
-    libx11-dev \
     gcc-11 \
     g++-11 \
     clang-11 \
-    cmake \
-    pkg-config \
-    build-essential \
-    libssl-dev \
     && rm -rf /var/lib/apt/lists/*
 
-# Rust toolchain: some dependencies only ship sdists on aarch64 and need cargo
-# to build. The dormant legacy Modal image layers the identical apt set +
-# rustup on top of this image (fastvideo/tests/modal/pr_test.py); baking both
-# here keeps its manual rollback path reproducible without changing the Slurm
-# runner's package surface.
-RUN set -o pipefail && \
-    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain stable --profile minimal && \
-    /root/.cargo/bin/cargo --version && /root/.cargo/bin/rustc --version
-ENV PATH=/root/.cargo/bin:${PATH}
-
 # Set up C++20 compilers for ThunderKittens
 RUN update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 100 --slave /usr/bin/g++ g++ /usr/bin/g++-11
 
@@ -156,7 +138,6 @@ RUN --mount=type=cache,target=/opt/uv/cache \
     source /opt/venv/bin/activate && \
     uv pip install --upgrade pip && \
     uv pip install --excludes docker/uv-excludes ".[dev]" && \
-    python -c "import cv2; print('OpenCV', cv2.__version__)" && \
     PYTAG=cp$(echo "${PYTHON_VERSION}" | tr -d .) && \
     case "${TARGETARCH:-amd64}" in \
         amd64) \
@@ -188,21 +169,26 @@ RUN --mount=type=cache,target=/opt/uv/cache \
 # flash_attn/__init__.py), so FA2/varlen/bert_padding stay from the install above;
 # rmtree clears the wheel's stale cute files first to avoid an install conflict.
 # Then verify both survive so a broken overlay fails the build instead of shipping
-# an FA2-less image. The pinned stack is validated on ARM64 GB200 (sm_100) as well
-# as x86; FA4 remains opt-in through FASTVIDEO_FA4=1 so lanes with FA2 baselines
-# keep their existing numerics.
+# an FA2-less image. x86 only: the FA4 stack (quack-kernels etc.) is unvalidated on
+# arm64 / GB10 (sm_121), so there we skip the overlay; FA4 is opt-in
+# (FASTVIDEO_FA4=1) and errors if set without the overlay, so leave it unset on
+# arm64 and the image runs FA3/FA2 as usual.
 RUN --mount=type=cache,target=/opt/uv/cache \
     source $HOME/.local/bin/env && \
     source /opt/venv/bin/activate && \
-    python -c "import glob, shutil; [shutil.rmtree(d, ignore_errors=True) for d in glob.glob('/opt/venv/lib/python*/site-packages/flash_attn/cute')]" && \
-    uv pip install "flash-attn-4 @ git+https://github.com/Dao-AILab/flash-attention.git@${FA4_CUTE_REF}#subdirectory=flash_attn/cute" && \
-    python -c "import flash_attn; assert hasattr(flash_attn, 'flash_attn_func'), 'FA2 was clobbered by the cute overlay'; import flash_attn.cute; print('FA2 + FA4 cute OK')"
+    if [ "${TARGETARCH}" = "arm64" ]; then \
+        echo "Skipping FA4 cute overlay on arm64 (FA4 stack unvalidated there; do not set FASTVIDEO_FA4)"; \
+    else \
+        python -c "import glob, shutil; [shutil.rmtree(d, ignore_errors=True) for d in glob.glob('/opt/venv/lib/python*/site-packages/flash_attn/cute')]" && \
+        uv pip install "flash-attn-4 @ git+https://github.com/Dao-AILab/flash-attention.git@${FA4_CUTE_REF}#subdirectory=flash_attn/cute" && \
+        python -c "import flash_attn; assert hasattr(flash_attn, 'flash_attn_func'), 'FA2 was clobbered by the cute overlay'; import flash_attn.cute; print('FA2 + FA4 cute OK')"; \
+    fi
 
 COPY . .
 
 # Build immutable FastVideo kernel wheels for the published image. The requested
 # architecture remains installed for normal image users; amd64 images also carry
-# an SM89 artifact for L40S users and the dormant legacy rollback path.
+# an SM89 artifact so the predominant L40S Modal lanes can reuse it exactly.
 ARG FASTVIDEO_KERNEL_PREBUILT_DIR=/opt/fastvideo-kernel-prebuilt
 RUN --mount=type=cache,target=/opt/uv/cache \
     source $HOME/.local/bin/env && \

docs/assets/cookbook-recipes.json

@@ -1,52 +0,0 @@
-{
-  "recipes": [
-    {
-      "id": "fastwan21-t2v",
-      "task": "Text to video",
-      "label": "FastWan2.1 1.3B (distilled + VSA)",
-      "model": "FastVideo/FastWan2.1-T2V-1.3B-Diffusers",
-      "source": "scripts/inference/inference_wan_VSA_DMD_1_3B.yaml",
-      "command": "FASTVIDEO_ATTENTION_BACKEND=VIDEO_SPARSE_ATTN fastvideo generate --config scripts/inference/inference_wan_VSA_DMD_1_3B.yaml"
-    },
-    {
-      "id": "wan22-t2v",
-      "task": "Text to video",
-      "label": "Wan2.2 A14B",
-      "model": "Wan-AI/Wan2.2-T2V-A14B-Diffusers",
-      "source": "examples/inference/basic/basic_wan2_2.py",
-      "command": "python examples/inference/basic/basic_wan2_2.py"
-    },
-    {
-      "id": "wan21-i2v",
-      "task": "Image to video",
-      "label": "Wan2.1 14B 480P",
-      "model": "Wan-AI/Wan2.1-I2V-14B-480P-Diffusers",
-      "source": "scripts/inference/inference_wan_i2v.yaml",
-      "command": "fastvideo generate --config scripts/inference/inference_wan_i2v.yaml"
-    },
-    {
-      "id": "turbowan22-i2v",
-      "task": "Image to video",
-      "label": "TurboWan2.2 A14B",
-      "model": "loayrashid/TurboWan2.2-I2V-A14B-Diffusers",
-      "source": "examples/inference/basic/basic_turbodiffusion_i2v.py",
-      "command": "python examples/inference/basic/basic_turbodiffusion_i2v.py"
-    },
-    {
-      "id": "wan22-ti2v",
-      "task": "Text or image to video",
-      "label": "Wan2.2 TI2V 5B",
-      "model": "Wan-AI/Wan2.2-TI2V-5B-Diffusers",
-      "source": "examples/inference/basic/basic_wan2_2_ti2v.py",
-      "command": "python examples/inference/basic/basic_wan2_2_ti2v.py"
-    },
-    {
-      "id": "matrix-game-2",
-      "task": "Interactive world",
-      "label": "Matrix Game 2.0",
-      "model": "FastVideo/Matrix-Game-2.0-Base-Distilled-Diffusers",
-      "source": "examples/inference/basic/basic_matrixgame2.py",
-      "command": "python examples/inference/basic/basic_matrixgame2.py"
-    }
-  ]
-}

docs/assets/cookbook.js

@@ -1,60 +0,0 @@
-(() => {
-  let recipesPromise;
-
-  const loadRecipes = (url) => {
-    recipesPromise ||= fetch(url).then((response) => {
-      if (!response.ok) throw new Error(`HTTP ${response.status}`);
-      return response.json();
-    });
-    return recipesPromise;
-  };
-
-  const init = () => {
-    document.querySelectorAll("[data-cookbook]").forEach(async (root) => {
-      if (root.dataset.initialized) return;
-      root.dataset.initialized = "true";
-
-      const select = root.querySelector("[data-cookbook-recipe]");
-      const model = root.querySelector("[data-cookbook-model]");
-      const source = root.querySelector("[data-cookbook-source]");
-      const command = root.querySelector("[data-cookbook-command]");
-      const status = root.querySelector("[data-cookbook-status]");
-
-      try {
-        const { recipes } = await loadRecipes(root.dataset.recipes);
-        const byId = new Map(recipes.map((recipe) => [recipe.id, recipe]));
-        const groups = new Map();
-
-        select.replaceChildren();
-        recipes.forEach((recipe) => {
-          if (!groups.has(recipe.task)) {
-            const group = document.createElement("optgroup");
-            group.label = recipe.task;
-            groups.set(recipe.task, group);
-            select.append(group);
-          }
-          groups.get(recipe.task).append(new Option(recipe.label, recipe.id));
-        });
-
-        const render = () => {
-          const recipe = byId.get(select.value);
-          model.textContent = recipe.model;
-          source.textContent = recipe.source;
-          source.href = `https://github.com/hao-ai-lab/FastVideo/blob/main/${recipe.source}`;
-          command.textContent = recipe.command;
-          status.textContent = `${recipe.label} selected.`;
-        };
-
-        select.addEventListener("change", render);
-        select.disabled = false;
-        render();
-      } catch (error) {
-        status.textContent = "Recipes could not be loaded. Use the examples link below.";
-        console.error("Failed to load FastVideo cookbook recipes", error);
-      }
-    });
-  };
-
-  if (window.document$) window.document$.subscribe(init);
-  else document.addEventListener("DOMContentLoaded", init);
-})();

docs/assets/custom.css

@@ -42,46 +42,6 @@ img {
     margin: 0 auto;
 }
 
-.cookbook-picker {
-    padding: 1rem;
-    border: 0.05rem solid var(--md-default-fg-color--lightest);
-    border-radius: 0.2rem;
-}
-
-.cookbook-picker select {
-    width: 100%;
-    padding: 0.6rem;
-    color: var(--md-default-fg-color);
-    background: var(--md-default-bg-color);
-    border: 0.05rem solid var(--md-default-fg-color--lighter);
-    border-radius: 0.2rem;
-}
-
-.cookbook-picker dl {
-    display: grid;
-    grid-template-columns: max-content 1fr;
-    gap: 0.25rem 1rem;
-}
-
-.cookbook-picker dt {
-    font-weight: 700;
-}
-
-.cookbook-picker dd {
-    margin: 0;
-    min-width: 0;
-    overflow-wrap: anywhere;
-}
-
-.cookbook-picker__status {
-    position: absolute;
-    width: 1px;
-    height: 1px;
-    overflow: hidden;
-    clip: rect(0, 0, 0, 0);
-    white-space: nowrap;
-}
-
 .md-typeset .copy-page-button.md-button {
     float: right;
     margin: 0 0 1rem 1rem;

docs/contributing/ci_architecture.md

@@ -6,8 +6,7 @@ lives in [Testing](testing.md).
 
 ## Overview
 
-FastVideo splits validation across GitHub Actions, Buildkite, Slinky Slurm,
-and Mergify:
+FastVideo splits validation across GitHub Actions, Buildkite, and Modal:
 
 ```text
 PR opened or updated
@@ -17,24 +16,17 @@ PR opened or updated
   |     style, lint, type, spelling, Markdown, workflow syntax, filenames
   |
   |-- Tier 2: Fastcheck
-  |     Buildkite schedules six lanes on the Slinky Slurm cluster
-  |     encoder, VAE, transformer, kernel, unit, DreamVerse
+  |     Buildkite orchestrates Modal GPU jobs
+  |     path-filtered component and unit checks
   |
-  |-- /merge or ready label
+  |-- /merge, /test full, or ready label
         |
-        `-- Tier 3: Change-aware merge gate
-              trusted base-branch planner classifies the complete PR diff
-              Buildkite adds only relevant integration, quality, training,
-              API, or performance lanes on Slinky Slurm
+        `-- Tier 3: Full Suite
+              Buildkite orchestrates Modal GPU jobs
+              path-filtered integration, SSIM, training, eval, and performance checks
               |
               pass -> Mergify squash-merges when all merge conditions pass
               fail -> fix, push, and re-run
-
-  |-- /test full
-        `-- Explicit all-20-lane diagnostic run
-
-  `-- weekly schedule on main
-        `-- Complete four-GPU SSIM matrix
 ```
 
 CI is not one monolithic job:
@@ -42,31 +34,10 @@ CI is not one monolithic job:
 - GitHub Actions owns pre-commit, slash-command handling, aggregate status
   updates, docs deployment, image builds, package publishing, and community
   automations.
-- Buildkite owns the GPU test graph, statuses, and trusted dispatch control
-  plane. Its agent runs on the Slurm login plane; it does not execute test
-  payloads.
-- Slinky Slurm is the only active CI compute backend. A host-owned dispatcher
-  leases GPUs from a persistent four-GPU allocation and runs each lane in an
-  isolated Enroot container at the immutable PR SHA.
+- Buildkite owns the GPU test pipeline and path filtering.
+- Modal owns the actual GPU execution environment for test jobs.
 - Mergify owns merge protection, labeling, and the final squash merge.
 
-The old files under `fastvideo/tests/modal/` are retained as dormant manual
-rollback code. `.buildkite/scripts/pr_test.sh` rejects Buildkite invocations,
-and no pipeline or slash-command route calls Modal.
-
-Three Buildkite entry pipelines share the validated graph:
-
-| Pipeline | Trigger | Scope |
-|---|---|---|
-| `pr-fastcheck` | Automatic pull-request webhook | Six Fastcheck lanes |
-| `ci` | `/merge`, `ready`, schedules, and `/test` API builds | Change-aware merge gates, scheduled SSIM, explicit Full Suite, Fastcheck reruns, or one direct lane |
-| `fastvideo-performance-lane` | Weekly scheduler | Direct performance lane |
-
-Each entry pipeline starts with the same trusted `pipeline-upload` job on the
-`ci-runner` queue. The `ci` pipeline's incoming GitHub webhook is disabled;
-otherwise it would duplicate the automatic `pr-fastcheck` build. API and
-scheduled builds continue to work with webhook processing disabled.
-
 ## CI Tiers
 
 ### Tier 1: Pre-commit
@@ -99,37 +70,34 @@ debugging a hook implementation.
 | Attribute | Value |
 |---|---|
 | Triggered by | Buildkite PR builds with `TEST_SCOPE=fastcheck` or unset |
-| Compute | Slinky Slurm (`ci-runner` queue) |
+| Runner | Buildkite agent that launches Modal GPU jobs |
 | Definition | `.buildkite/pipeline.yml` |
-| Entrypoint | Trusted host driver -> `.buildkite/scripts/unit_test.sh` or `.buildkite/scripts/lanes/*.sh` |
+| Entrypoint | `.buildkite/scripts/pr_test.sh` -> `fastvideo/tests/modal/pr_test.py` |
 
-Fastcheck always schedules these six lanes: encoder, VAE, transformer, custom
-kernels, unit tests, and DreamVerse. Static steps replace the former
-host-side path-filter plugin: the login plane never checks out or executes PR
-code.
+Fastcheck uses Buildkite's `monorepo-diff` plugin. Jobs whose watched paths did
+not change are skipped and do not block the aggregate `fastcheck-passed`
+status.
 
-### Tier 3: Change-Aware Merge Gate
+| Buildkite label | `TEST_TYPE` | Main watched paths |
+|---|---|---|
+| Encoder Tests | `encoder` | `fastvideo/models/encoders/**`, `fastvideo/models/loader/**`, `fastvideo/tests/encoders/**`, `pyproject.toml`, `docker/Dockerfile` |
+| VAE Tests | `vae` | `fastvideo/models/vaes/**`, `fastvideo/models/loader/**`, `fastvideo/tests/vaes/**`, `pyproject.toml`, `docker/Dockerfile` |
+| Transformer Tests | `transformer` | `fastvideo/models/dits/**`, `fastvideo/models/loader/**`, `fastvideo/tests/transformers/**`, `fastvideo/layers/**`, `fastvideo/attention/**`, `pyproject.toml`, `docker/Dockerfile` |
+| Kernel Tests | `kernel_tests` | `fastvideo-kernel/**`, `pyproject.toml`, `docker/Dockerfile` |
+| Unit Tests | `unit_test` | `fastvideo/**`, `.buildkite/**`, `.github/**`, `pyproject.toml`, `docker/Dockerfile` |
+| DreamVerse App Tests | `dreamverse_app` | `apps/dreamverse/**`, `pyproject.toml` |
+
+### Tier 3: Full Suite
 
 | Attribute | Value |
 |---|---|
-| Triggered by | `/merge`, adding `ready`, or a new push to a PR that already has `ready` |
-| Compute | Slinky Slurm only (`ci-runner` queue) |
+| Triggered by | `/merge`, adding `ready`, `/test full`, or a new push to a PR that already has `ready` |
+| Runner | Buildkite agent that launches Modal GPU jobs |
 | Definition | `.buildkite/pipeline.yml` |
-| Entrypoint | `/opt/fastvideo-ci-runner/run-ci` (`run-unit` is a compatibility wrapper) |
+| Entrypoint | `.buildkite/scripts/pr_test.sh` -> `fastvideo/tests/modal/pr_test.py` |
 
-Fastcheck is the universal six-lane baseline. The merge gate does not repeat
-those jobs: it classifies every changed path and adds only the relevant lanes
-from the fourteen-lane integration set below. Selected jobs are hard gates;
-there are no soft-fail hardware lanes. A documentation-only PR can therefore
-finish its merge build after the trusted uploader, while model-family changes
-typically add focused golden-gate and SSIM files and a training-only change
-adds only its owning training lane.
-
-`.github/scripts/plan_merge_ci.py` is the canonical path policy. It runs from
-the immutable base SHA under `pull_request_target`; PR code is never executed
-on the GitHub runner. The changed-file list includes both sides of renames. An
-API failure, truncated response, empty list, unknown build input, or unknown
-source path fails closed to all fourteen integration lanes.
+Full Suite is also path-filtered. It validates broader behavior before Mergify
+can merge a PR.
 
 A `ready`-labeled PR does not hit Buildkite immediately:
 `ci-trigger-full-suite.yml` first runs `.github/scripts/gate_full_suite.sh`,
@@ -138,100 +106,25 @@ head. A red cheap check blocks the suite (fail closed; the next push re-arms
 it), while a GitHub outage or a >25 min wait lets it run anyway (fail open).
 `/test full` bypasses the gate.
 
-The complete static graph remains available through `/test full`; path
-selection never deletes or dynamically invents a Buildkite step.
-
-| Lane | Public `TEST_TYPE` | GPUs | Typical merge trigger |
-|---|---|---:|---|
-| Encoder | `encoder` | 1 | Universal Fastcheck |
-| VAE | `vae` | 1 | Universal Fastcheck |
-| Transformer | `transformer` | 1 | Universal Fastcheck |
-| Kernel | `kernel_tests` | 1 | Universal Fastcheck |
-| Unit | `unit_test` | 1 | Universal Fastcheck |
-| DreamVerse | `dreamverse_app` | 1 | Universal Fastcheck |
-| Golden gate | `golden_gate` | 1 | Model, pipeline, attention, layer, or output changes |
-| SSIM | `ssim` | 4 | Matching model/SSIM paths; focused files when possible |
-| LoRA inference | `inference_lora` | 1 | LoRA inference/shared LoRA paths |
-| LoRA extraction | `lora_extraction` | 1 | LoRA extraction/shared LoRA paths |
-| Vanilla training | `training` | 4 | Legacy vanilla/shared training paths |
-| DMD distillation | `distillation_dmd` | 2 | DMD/shared training paths |
-| Self-forcing | `self_forcing` | 2 | Self-forcing/shared training paths |
-| LoRA training | `training_lora` | 2 | LoRA/shared training paths |
-| VSA training | `training_vsa` | 2 | VSA/shared training paths |
-| VMoBA inference | `inference_vmoba` | 1 | VMoBA backend/config paths |
-| Performance | `performance` | 2 | Performance tests or benchmark policy |
-| API server | `api_server` | 1 | API, worker, or server entrypoint paths |
-| Modular train framework | `train_framework` | 1 | `fastvideo/train/` and its tests |
-| Eval metrics | `eval` | 1 | `fastvideo/eval/` and its tests |
-
-Golden-gate and SSIM selections are basenames, not arbitrary pytest arguments.
-The private host checks the comma-separated allowlist before staging, and the
-container checks it again before invoking pytest. Shared quality-harness
-changes still run the complete owning lane. The full SSIM matrix also runs on
-`main` every Sunday at 05:00 UTC through `ci-scheduled-ssim.yml`; `/test ssim`
-and `/test full` remain available for deliberate complete runs.
-
-The four Buildkite workers may accept multiple jobs concurrently. The
-agent-owned lease broker packs their requested GPU counts onto one persistent
-four-GPU Slurm allocation and waits when capacity is full. A four-GPU lane
-such as SSIM or vanilla training owns the whole tray; two two-GPU lanes or up
-to four one-GPU lanes can overlap without sharing devices. SSIM and vanilla
-training also share the `fastvideo/slinky/whole-tray` Buildkite concurrency
-group. That keeps the second whole-tray lane in Buildkite instead of consuming
-an agent and its command timeout while the first lane waits for four free GPUs.
-Because packed Enroot containers share the node network namespace, each GPU
-lease receives its own 100-port rendezvous range. Tests preserve the
-runner-assigned `MASTER_PORT`, and parallel SSIM tasks use distinct offsets
-inside that range.
+| Buildkite label | `TEST_TYPE` | Main watched paths |
+|---|---|---|
+| SSIM Tests | `ssim` | `fastvideo/**/*.py`, `pyproject.toml`, `docker/Dockerfile` |
+| LoRA Inference Tests | `inference_lora` | LoRA tests, loader, transformer tests, pipelines, LoRA layers |
+| LoRA Extraction Tests | `lora_extraction` | LoRA extraction scripts/tests, loader, training utilities, LoRA layers |
+| Training Tests | `training` | `fastvideo/**`, `pyproject.toml`, `docker/Dockerfile` |
+| Distillation DMD Tests | `distillation_dmd` | `fastvideo/training/*distillation_pipeline.py` |
+| Self-Forcing Tests | `self_forcing` | self-forcing distillation pipeline and tests |
+| LoRA Training Tests | `training_lora` | `fastvideo/**`, `pyproject.toml`, `docker/Dockerfile` |
+| Training Tests VSA | `training_vsa` | `fastvideo/**`, `fastvideo-kernel/**`, `pyproject.toml`, `docker/Dockerfile` |
+| Inference Tests VMoBA | `inference_vmoba` | `fastvideo-kernel/**`, `fastvideo/attention/backends/vmoba.py` |
+| Performance Tests | `performance` | DiTs, pipelines, attention, layers, worker, entrypoints, performance tests/configs |
+| API Server Tests | `api_server` | OpenAI entrypoints, serve CLI, OpenAI API integration test |
+| Train Framework Tests | `train_framework` | `fastvideo/train/**`, train model/method tests, model loader, DiTs |
+| Eval Metrics Tests | `eval` | `fastvideo/eval/**`, `fastvideo/tests/eval/**`, `pyproject.toml`, `docker/Dockerfile` |
 
 See [Performance Benchmarks](performance_benchmarks.md) for the performance
 lane's thresholds, rolling baseline, artifacts, and reseeding process.
 
-## `/merge` Request Flow
-
-The Buildkite agent and Slurm have deliberately separate responsibilities:
-
-```text
-/merge PR comment
-  -> GitHub verifies write permission and refreshes the `ready` label
-  -> base-branch `ci-trigger-full-suite` workflow fetches the PR file list,
-     computes MERGE_TEST_PLAN plus focused golden/SSIM basenames, and gates on
-     cheap checks
-  -> sends the PR SHA to pipeline `ci` with TEST_SCOPE=merge and FULL_SUITE=true
-  -> trusted `pipeline-upload` job on queue `ci-runner`
-       fetch exact-SHA .buildkite/pipeline.yml
-       normalize + validate the complete static 20-lane policy and conditions
-       upload static Buildkite steps
-  -> each accepted step reaches the host policy hook
-       validate org/repo/SHA/ref/step key/command/scope/timeout
-       skip checkout on the login plane
-       stage a mode-0600 request on Lustre
-       lease 1-4 GPUs and attach an `srun` step to the Slinky tray
-  -> Enroot worker container
-       clone and verify the exact PR SHA
-       install the lane's project extras and cached kernel
-       run the repository-owned lane script
-       write numeric exit status and approved artifacts
-  -> trusted host returns that status to Buildkite
-  -> Buildkite publishes `full-suite-passed` only when every selected lane passes
-```
-
-The pipeline uploader and dispatcher run on the Slurm login plane, but those
-are control-plane operations only. Python tests, model loading, CUDA kernels,
-Node/Playwright checks, inference, training, SSIM generation, and performance
-benchmarks all execute in Slurm allocations.
-
-PR-controlled values never become host commands. The host policy accepts only
-the pinned pipeline uploader or a known lane tuple. It rejects plugins,
-artifact globs, shell injection variables, non-immutable commits, and unknown
-commands before checkout. Hugging Face credentials are added only for lanes
-that declare them, passed through a mode-0600 request file, and removed before
-the PR payload starts. Active training lanes keep W&B offline and do not stage
-a W&B credential. The ARM64 image includes the pinned FA4 CuTe overlay validated
-on GB200. SSIM opts into FA4 to preserve its reference-video numerics; lanes
-with FA2 baselines keep `FASTVIDEO_FA4=0`. Performance artifacts are relayed
-afterward by the trusted host from an allowlisted directory and extension set.
-
 ## Slash Commands
 
 Slash commands are handled by `.github/workflows/ci-slash-commands.yml`.
@@ -239,7 +132,7 @@ Repository write permission is required.
 
 | Command | Effect |
 |---|---|
-| `/merge` | Adds `ready` and triggers the path-aware merge gate for the PR head. |
+| `/merge` | Adds `ready` and triggers Full Suite for the PR head branch. |
 | `/test full` | Runs the whole Full Suite with `TEST_SCOPE=full`. |
 | `/test fastcheck` | Runs the whole Fastcheck suite with `TEST_SCOPE=fastcheck`. |
 | `/test pre-commit` | Re-runs the pre-commit workflow on the PR merge ref. |
@@ -256,7 +149,6 @@ Valid direct test names:
 | `/test unit` | `unit_test` |
 | `/test dreamverse` | `dreamverse_app` |
 | `/test ssim` | `ssim` |
-| `/test golden-gate` | `golden_gate` |
 | `/test training` | `training` |
 | `/test lora-inference` | `inference_lora` |
 | `/test lora-training` | `training_lora` |
@@ -270,18 +162,12 @@ Valid direct test names:
 | `/test train-framework` | `train_framework` |
 | `/test eval` | `eval` |
 
-The temporary `<name>-ci` spellings remain accepted as compatibility aliases;
-they select the same Slurm lane and do not identify a second backend.
-
 When a direct test completes successfully, Buildkite posts
 `direct-test-completed`. `.github/workflows/ci-aggregate-status.yml` then reads
 the latest Buildkite statuses for the commit and updates `fastcheck-passed` or
 `full-suite-passed` if all jobs in that group are green.
 
-Buildkite label emojis define the status namespace used by that aggregation:
-`:microscope:` is reserved for the six Fastcheck lanes, while Full-Suite-only
-lanes use `:test_tube:` or `:bar_chart:`. Each active lane has exactly one
-label and therefore one status context.
+Skipped path-filtered jobs have no status entry and do not block the aggregate.
 
 ## Merge Protection
 
@@ -291,7 +177,7 @@ Mergify enforces these conditions before it squash-merges to `main`:
 |---|---|
 | `check-success~=pre-commit` | Tier 1 passed. |
 | `check-success=fastcheck-passed` | All triggered Fastcheck jobs passed. |
-| `check-success=full-suite-passed` | The selected merge gate or explicit Full Suite passed. |
+| `check-success=full-suite-passed` | All triggered Full Suite jobs passed. |
 | `#approved-reviews-by>=1` | At least one approving review. |
 | Valid title regex | PR title starts with an accepted `[type]` tag. |
 | `label=ready` | The PR has entered the merge flow. |
@@ -340,40 +226,29 @@ Process labels:
 
 | Label | Who sets it | Meaning |
 |---|---|---|
-| `ready` | `/merge` or maintainer action | Triggers/keeps the change-aware merge gate active and enables auto-merge. |
+| `ready` | `/merge` or maintainer action | Triggers/keeps Full Suite active and enables auto-merge. |
 | `needs-rebase` | Mergify | PR has merge conflicts. |
 | `do-not-merge` | Maintainer | Blocks merge regardless of CI status. |
 
-## Slurm Lane Entrypoints
+## Modal Test Entrypoints
 
-Every active test selection lives in `.buildkite/scripts/unit_test.sh` or a
-focused `.buildkite/scripts/lanes/<lane>.sh`. The private, agent-owned lane
-table binds each internal `*_ci` type to that script, its GPU count, wall-clock
-limit, dependency extras, kernel-build policy, secrets, and artifacts. The
-internal suffix is an implementation detail; there is only one active backend.
+All Buildkite test jobs go through `.buildkite/scripts/pr_test.sh`, which:
 
-SSIM uses `fastvideo/tests/ssim/ci_runner.py` inside a single four-GPU lease.
-It discovers `REQUIRED_GPUS` and `*_MODEL_TO_PARAMS` with AST parsing, then
-packs independent pytest subprocesses across the visible GPUs with fail-fast
-termination. Performance writes reports to a host-mounted artifact directory;
-the host uploads only `.md`, `.html`, `.json`, and `.csv` files after the
-container exits.
-
-The Modal launchers remain in the repository for manual rollback archaeology,
-but they are not CI entrypoints. `pr_test.sh` rejects Buildkite calls and needs
-`FASTVIDEO_ENABLE_LEGACY_MODAL_CI=1` even for a local manual invocation.
+1. Reads Buildkite secrets for Modal, Hugging Face, and W&B when needed.
+2. Selects a Modal function based on `TEST_TYPE`.
+3. Passes Buildkite metadata into the Modal container.
+4. Runs the selected test command from `fastvideo/tests/modal/pr_test.py` or
+   `fastvideo/tests/modal/ssim_test.py`.
+5. Uploads performance artifacts for `TEST_TYPE=performance`.
 
 If you add a new CI test category:
 
-1. Add an executable `.buildkite/scripts/lanes/<lane>.sh` containing the test
-   payload only.
-2. Add the static Buildkite step in `.buildkite/pipeline.yml`, its source/test
-   ownership in `.github/scripts/plan_merge_ci.py`, and the `/test` mapping in
-   `.github/workflows/ci-slash-commands.yml`.
-3. Extend `fastvideo/tests/contract/test_ci_test_collection.py`,
-   `test_merge_ci_plan.py`, and the trusted private runner's lane table plus
-   uploader policy in the same rollout.
-4. Validate on the target GB200 hardware before making the lane a merge gate.
+1. Add the Modal function in `fastvideo/tests/modal/pr_test.py` or a focused
+   companion module.
+2. Add the `TEST_TYPE` case in `.buildkite/scripts/pr_test.sh`.
+3. Add the Buildkite direct-test step and any Fastcheck/Full Suite path filters
+   in `.buildkite/pipeline.yml`.
+4. Add or update the `/test` mapping in `.github/workflows/ci-slash-commands.yml`.
 5. Document the lane here and link any domain-specific authoring guide.
 
 ## CD And Release Workflows
@@ -407,18 +282,13 @@ the explicit `py3.12-cuda13.0.0-latest` tag. This publication policy does not
 change the unparameterized `docker/Dockerfile` build defaults, which remain CUDA
 13 and `cu130`.
 
-Published development images carry architecture-specific kernel wheels under
-`/opt/fastvideo-kernel-prebuilt`. The Slurm worker selects the exact source,
-ABI, and GPU-architecture match, so normal lanes reuse the trusted artifact
-while kernel-changing PRs still build locally. Once a kernel or artifact-key
-change reaches `main`, the image workflow republishes the matching artifact
-before later jobs consume the updated image pin.
-
-The same workflow publishes a single-architecture ARM64, CUDA 13, SM100 image
-for the self-hosted CI runner under the
-`py3.12-cuda13.0.0-sm100-{latest,sha-*}` tags. It carries the matching prebuilt
-kernel wheel so runner jobs can validate and install the exact source and ABI
-match instead of recompiling it in every lane.
+Published amd64 development images keep their configured Hopper kernel wheel
+installed and also carry an immutable SM89 wheel under
+`/opt/fastvideo-kernel-prebuilt`. Modal PR and SSIM jobs select the exact
+source, ABI, and GPU-architecture match from that directory, so L40S jobs reuse
+the trusted image artifact while kernel-changing PRs still build locally. Once
+a kernel or artifact-key change reaches `main`, the image workflow republishes
+the matching trusted artifact before later jobs consume the updated image tag.
 
 The optional Dreamverse matrix builds backend and UI images for CUDA 12.6 and
 CUDA 13 on `amd64`. Dreamverse remains `amd64`-only because its FA4 dependency
@@ -450,17 +320,15 @@ The reusable implementation lives in
 | `.github/mergify.yml` | Merge protection, PR title validation, PR labels, conflict labels, auto-merge |
 | `.github/workflows/ci-precommit.yml` | Tier 1 pre-commit |
 | `.github/workflows/ci-slash-commands.yml` | `/merge` and `/test` handling |
-| `.github/workflows/ci-trigger-full-suite.yml` | Change-aware merge-gate trigger for `ready` PRs and new pushes |
-| `.github/workflows/ci-scheduled-ssim.yml` | Weekly complete SSIM trigger on `main` |
-| `.github/scripts/plan_merge_ci.py` | Trusted changed-path to integration-lane planner |
-| `.github/workflows/ci-aggregate-status.yml` | Aggregate Fastcheck and explicit Full Suite direct-rerun statuses |
-| `.buildkite/pipeline.yml` | Static 20-lane Slurm Buildkite graph |
-| `.buildkite/scripts/unit_test.sh`, `.buildkite/scripts/lanes/*.sh` | Active Slurm lane payloads |
-| `fastvideo/tests/ssim/ci_runner.py` | Four-GPU Slurm SSIM scheduler |
-| `.buildkite/scripts/pr_test.sh`, `fastvideo/tests/modal/*.py` | Dormant manual Modal rollback path (disabled in Buildkite) |
+| `.github/workflows/ci-trigger-full-suite.yml` | Full Suite trigger for `ready` PRs and new pushes to ready PRs |
+| `.github/workflows/ci-aggregate-status.yml` | Aggregate Fastcheck/Full Suite commit statuses |
+| `.buildkite/pipeline.yml` | Buildkite test graph and path filters |
+| `.buildkite/scripts/pr_test.sh` | Buildkite-to-Modal test dispatcher |
+| `fastvideo/tests/modal/pr_test.py` | Modal functions for most GPU CI lanes |
+| `fastvideo/tests/modal/ssim_test.py` | Modal functions and partitioning for SSIM |
 | `.buildkite/performance-benchmarks/tests/*.json` | Performance benchmark configs and thresholds |
 | `.github/workflows/infra-docs.yml` | Docs build and GitHub Pages deploy |
-| `.github/workflows/infra-build-image.yml` | CUDA matrix, CI runner image, and manual Docker image builds |
+| `.github/workflows/infra-build-image.yml` | Automatic CUDA matrix and manual Docker image builds |
 | `.github/workflows/publish-fastvideo.yml` | FastVideo PyPI publishing |
 | `.github/workflows/publish-kernel.yml` | FastVideo kernel PyPI publishing |
 | `.github/workflows/publish-comfyui.yml` | ComfyUI registry publishing |

docs/contributing/performance_benchmarks.md

@@ -23,8 +23,8 @@ It serves three audiences:
 pytest fastvideo/tests/performance/ -vs
 
 # Optional: compare against the rolling HF baseline.
-# PERF_REPORTS_DIR defaults to /root/data/perf_reports in a CI container, so
-# override it for a local run.
+# PERF_REPORTS_DIR defaults to /root/data/perf_reports for Modal/CI, so
+# override it when running outside the container.
 PERF_REPORTS_DIR=/tmp/fastvideo_perf_reports \
 python fastvideo/tests/performance/compare_baseline.py
 
@@ -459,18 +459,16 @@ FlashInfer, Cutlass DSL, SageAttention, Triton, and xFormers when installed.
 | `FASTVIDEO_FA4` | `0` | `test_inference_performance.py` | FlashAttention-4 toggle included in `software_profile_id`. |
 | `FASTVIDEO_PERFORMANCE_PROFILE_VERSION` | unset | `test_inference_performance.py` | Optional explicit software cohort/profile version included in `software_profile_id`. |
 | `IMAGE_VERSION` | unset | `test_inference_performance.py` | CI container image/profile version included in `software_profile_id` when available. |
-| `FASTVIDEO_CONTAINER_IMAGE_REF` | unset | Slurm runner, `test_inference_performance.py` | Pinned CI container image digest recorded in `environment_metadata` and `software_profile_id`. |
+| `FASTVIDEO_CONTAINER_IMAGE_REF` | unset | `pr_test.py`, `launch_l40s_job.py`, `test_inference_performance.py` | Resolved CI container image ref or digest recorded in `environment_metadata` for audit without changing `software_profile_id`. |
 | `FASTVIDEO_STAGE_LOGGING` | set by the pytest test | `test_inference_performance.py` | Enables pipeline stage timing capture for component metrics during benchmark runs. |
 
 ## CI integration
 
-The performance step can run on demand with `/test performance`, through a
-merge gate when performance tests or benchmark policy changed, and as part of
-an explicit `/test full` run (see [CI/CD Architecture](ci_architecture.md)).
-The weekly `fastvideo-performance-lane` schedule runs the same Slurm payload.
-The active entry point is `.buildkite/scripts/lanes/performance.sh`; the
-trusted host dispatcher relays its allowlisted reports to Buildkite after the
-isolated container exits.
+The performance step can run on demand with `/test performance` and as part of
+the Full Suite (see [CI/CD Architecture](ci_architecture.md)). The Modal entry
+point is `fastvideo/tests/modal/pr_test.py:run_performance_tests` and the
+Buildkite artifact upload is in
+`.buildkite/scripts/pr_test.sh:upload_performance_artifacts`.
 
 Each performance build runs pytest first. PR and direct runs only continue to
 `compare_baseline.py` when that fixed-threshold phase passes; if pytest fails,

docs/contributing/profiling.md

@@ -1,8 +1,5 @@
 # Profiling FastVideo
 
-For GB200 sequence-parallel transport tuning and its long-training memory
-policy, see [Ulysses performance](ulysses_performance.md).
-
 !!! warning
     Profiling is only intended for FastVideo developers and maintainers to understand the proportion of time spent in different parts of the codebase. **FastVideo end-users should never turn on profiling** as it will significantly slow down inference.
 

docs/contributing/pull_requests.md

@@ -42,20 +42,19 @@ The important process labels are:
 
 | Label | Meaning |
 |---|---|
-| `ready` | The PR is ready for the change-aware merge gate and auto-merge consideration. |
+| `ready` | The PR is ready for Full Suite and auto-merge consideration. |
 | `needs-rebase` | The PR has merge conflicts with `main`. |
 | `do-not-merge` | A maintainer has blocked merge. |
 
 ## CI Summary
 
-FastVideo has three routine validation tiers plus an explicit full diagnostic:
+FastVideo has three validation tiers:
 
 | Tier | Runs when | What it does |
 |---|---|---|
 | Pre-commit | Pull requests and `/test pre-commit` | Formatting, linting, typing, spelling, Markdown, workflow syntax, filename checks |
-| Fastcheck | PR Buildkite builds | Six component, kernel, unit, and app lanes on Slinky Slurm |
-| Merge gate | `/merge`, `ready`, or new pushes to ready PRs | Only path-relevant integration lanes on Slinky Slurm; Fastcheck remains the baseline |
-| Full Suite | `/test full` | Explicit all-twenty-lane diagnostic run on Slinky Slurm |
+| Fastcheck | PR Buildkite builds | Path-filtered component and unit checks on Modal GPU runners |
+| Full Suite | `/merge`, `ready`, `/test full`, or new pushes to ready PRs | Path-filtered integration, SSIM, training, eval, API, and performance checks |
 
 See [CI/CD Architecture](ci_architecture.md#ci-tiers) for exact jobs, path
 filters, and workflow files.
@@ -67,11 +66,10 @@ filters, and workflow files.
 3. Fix pre-commit failures locally with `pre-commit run --all-files`.
 4. Wait for at least one approving review.
 5. When the PR is approved and ready, comment `/merge`.
-6. `/merge` adds `ready`, waits for cheap checks, and triggers the minimal
-   path-relevant integration lanes for the PR branch.
+6. `/merge` adds `ready` and triggers the Full Suite for the PR branch.
 7. If all required checks pass, Mergify squash-merges the PR to `main`.
-8. If the merge gate fails, fix the regression, push again, and re-run
-   `/merge`. Use a targeted `/test` command for diagnosis.
+8. If Full Suite fails, fix the regression, push again, and re-run `/merge` or
+   the failed test.
 
 Only contributors with repository write permission can use slash commands. If
 you are an external contributor, ask a maintainer to run `/merge` or add
@@ -130,7 +128,7 @@ git push --force-with-lease
 
 Mergify removes `needs-rebase` after conflicts are resolved.
 
-### Merge Gate Or Full Suite Fails
+### Full Suite Fails
 
 The failing Buildkite step is the source of truth. Common causes are:
 

docs/contributing/testing.md

@@ -138,31 +138,47 @@ pytest fastvideo/tests/ssim/ -vs
 
 Use a machine whose GPU and backend match the reference folder you are testing.
 
-## Slurm CI Runs For SSIM
+## Modal Runs For SSIM
 
-Comment `/test ssim` on a pull request to run the canonical four-GPU SSIM
-lane on the Slinky Slurm cluster. `fastvideo/tests/ssim/ci_runner.py`
-discovers the suite without importing test modules, packs independent pytest
-processes across the four assigned GPUs, and stops the lane on the first
-failure.
-
-The change-aware `/merge` planner may run only the SSIM test basenames owned
-by the changed model family. Shared SSIM harness changes still select the
-complete lane. Independently, `main` runs the full SSIM matrix every Sunday at
-05:00 UTC so infrequently touched model families retain periodic coverage.
-
-For a focused developer run, invoke pytest directly and optionally select one
-model from a parameterized test through `FASTVIDEO_SSIM_MODEL_ID`:
+For CI-like SSIM execution, use `fastvideo/tests/modal/ssim_test.py`:
 
 ```bash
-pytest fastvideo/tests/ssim/test_wan_t2v_similarity.py -vs
-
-FASTVIDEO_SSIM_MODEL_ID=Wan2.1-T2V-1.3B-Diffusers \
-pytest fastvideo/tests/ssim/test_wan_t2v_similarity.py -vs
+python -m modal run fastvideo/tests/modal/ssim_test.py::run_ssim_tests
 ```
 
-The files under `fastvideo/tests/modal/` are retained only as a disabled
-manual rollback implementation. No active CI trigger invokes them.
+Target specific files or model ids:
+
+```bash
+python -m modal run fastvideo/tests/modal/ssim_test.py::run_ssim_tests \
+  --test-files test_wan_t2v_similarity.py \
+  --model-ids Wan2.1-T2V-1.3B-Diffusers
+```
+
+If `HF_API_KEY`, `HUGGINGFACE_HUB_TOKEN`, or `HF_TOKEN` is not set, the local
+entrypoint fails fast.
+
+To export raw generated videos from Modal to the shared volume:
+
+```bash
+python -m modal run fastvideo/tests/modal/ssim_test.py::run_ssim_tests \
+  --sync-generated-to-volume
+```
+
+The raw export path is quality-tiered:
+
+- default params: `ssim_generated_videos/default/<subdir>/generated_videos`
+- full-quality params: `ssim_generated_videos/full_quality/<subdir>/generated_videos`
+
+The printed `modal volume get` command downloads into
+`./generated_videos_modal/<quality-tier>`. Convert those outputs into local
+references with `copy-local`:
+
+```bash
+python fastvideo/tests/ssim/reference_videos_cli.py copy-local \
+  --quality-tier full_quality \
+  --generated-dir ./generated_videos_modal/full_quality/L40S_reference_videos \
+  --device-folder L40S_reference_videos
+```
 
 ### SSIM Bootstrap Mode
 
@@ -190,30 +206,28 @@ python fastvideo/tests/ssim/reference_videos_cli.py promote-draft \
 
 ## CI Integration
 
-FastVideo GPU CI is orchestrated by Buildkite and runs only on isolated Slinky
-Slurm workers. The main files are:
+FastVideo CI tests are orchestrated by Buildkite and run on Modal GPU
+instances. The main files are:
 
 | File | Purpose |
 |---|---|
-| `.buildkite/pipeline.yml` | Static, validated 20-lane Slurm test graph. |
-| `.github/scripts/plan_merge_ci.py` | Trusted path-to-lane and focused quality-test policy for `/merge`. |
-| `.buildkite/scripts/unit_test.sh`, `.buildkite/scripts/lanes/*.sh` | Repository-owned test payloads executed inside Slurm containers. |
-| `fastvideo/tests/ssim/ci_runner.py` | Four-GPU SSIM task discovery and scheduling. |
-| `.buildkite/scripts/pr_test.sh`, `fastvideo/tests/modal/*.py` | Dormant manual rollback path; rejected in Buildkite. |
+| `.buildkite/pipeline.yml` | Buildkite test graph and path filters. |
+| `.buildkite/scripts/pr_test.sh` | Dispatches `TEST_TYPE` to a Modal function. |
+| `fastvideo/tests/modal/pr_test.py` | Modal functions for most test lanes. |
+| `fastvideo/tests/modal/ssim_test.py` | Modal functions and partitioning for SSIM. |
 
-For exact tier membership, slash commands, runner isolation, and aggregate statuses,
+For exact tier membership, path filters, slash commands, and aggregate statuses,
 see [CI/CD Architecture](ci_architecture.md).
 
 ### Adding A New CI Test Category
 
 If a new test does not fit an existing lane:
 
-1. Put the test payload in an executable `.buildkite/scripts/lanes/<lane>.sh`.
-2. Add its static step to `.buildkite/pipeline.yml`, its changed-path ownership
-   to `.github/scripts/plan_merge_ci.py`, and extend the CI contract tests.
-3. Add the `/test` mapping in `.github/workflows/ci-slash-commands.yml`.
-4. Coordinate the matching GPU, timeout, dependency, secret, and artifact
-   policy in the private Slurm runner allowlist.
+1. Add a Modal function in `fastvideo/tests/modal/pr_test.py` or a focused
+   companion module.
+2. Add a matching `TEST_TYPE` case in `.buildkite/scripts/pr_test.sh`.
+3. Add Buildkite direct-test and path-filter entries in `.buildkite/pipeline.yml`.
+4. Add the `/test` mapping in `.github/workflows/ci-slash-commands.yml`.
 5. Document the new category in [CI/CD Architecture](ci_architecture.md) and add
    authoring notes here if contributors need them.
 

docs/contributing/ulysses_performance.md

@@ -1,59 +0,0 @@
-# Ulysses performance on GB200
-
-Enable the fused transport with `FASTVIDEO_ULYSSES_A2A=auto` and rebuild
-`fastvideo-kernel` from the same checkout. The tuned path applies to contiguous
-BF16 operands with 56 global heads, head dimension 128, and sequence parallelism
-of four on GB200. It uses 144 CTAs and exchanges one batch plane at a time.
-Older kernel builds retain the original 36-CTA path.
-
-Each rank keeps at most 1 GiB of registered window storage. A 250,000-token
-sequence needs 896,000,000 bytes per plane with this geometry, so packed QKV or
-QKVG can use the fused path without a window large enough for the entire pack.
-The full output still needs its own GPU allocation. Chunking reduces registered
-storage; it does not remove activation or optimizer memory costs.
-
-Every call collectively agrees on geometry, window capacity, chunking and CTA
-count before entering the kernel. Outputs own their storage, and backward uses
-the plan saved by its forward. Contiguity alone does not replace these checks.
-Existing unsupported-layout, capture, topology and lifecycle fallbacks remain.
-
-## Long training sequences
-
-By default, grad-tracked operands whose per-plane size exceeds 512 MiB keep
-the original transport policy, including NCCL fallback for oversized packs.
-This avoids enabling a measured allocation-pressure regression in a 250k-token
-FSDP4 training recipe. No-grad inference can use tuned chunks directly.
-
-After configuring sufficient activation memory headroom, enable long training
-chunks explicitly:
-
-```bash
-export FASTVIDEO_ULYSSES_A2A=auto
-export FASTVIDEO_ULYSSES_A2A_LONG_TRAINING=chunked
-```
-
-An activation offload policy can provide that headroom. Measure the complete
-forward, backward, clipping and optimizer step with resident optimizer state;
-transport microbenchmarks alone do not predict long-sequence training speed.
-Compare allocator retries alongside step latency. Keep the allocator, FSDP
-mesh, attention backend, checkpointing and precision identical across routes.
-
-`FASTVIDEO_ULYSSES_A2A_LONG_TRAINING=auto` restores the conservative policy.
-The 512 MiB boundary describes a transport operand; it is not a model-wide
-activation-memory estimate. Revalidate other training recipes and hardware.
-
-## Validation
-
-CPU policy regressions live in
-`fastvideo/tests/distributed/test_ulysses_h3_policy.py`. On an exclusive group
-of four GB200 GPUs, run the native transport gate after rebuilding the kernel:
-
-```bash
-FASTVIDEO_ULYSSES_A2A=auto torchrun --standalone --nproc_per_node=4 \
-  fastvideo/tests/distributed/check_ulysses_h3_native.py
-```
-
-The gate covers exact transport gradients at 32k, 128k and 250k, the long
-training opt-in, retained-output ownership, and recovery after rank capability
-disagreement. Full-model throughput and absolute model FLOP utilization (MFU)
-are separate measurements; this transport gate reports neither.

docs/cookbook/index.md

@@ -1,44 +0,0 @@
-# Inference Cookbook
-
-Choose a complete recipe maintained in the FastVideo repository. Each command
-runs its checked-in source directly, so coupled model, GPU, offload, and
-attention settings do not drift into unsupported combinations.
-
-The commands expect a local clone:
-
-```bash
-git clone https://github.com/hao-ai-lab/FastVideo.git
-cd FastVideo
-```
-
-<div class="cookbook-picker" data-cookbook data-recipes="../assets/cookbook-recipes.json">
-  <label for="cookbook-recipe"><strong>Recipe</strong></label>
-  <select id="cookbook-recipe" data-cookbook-recipe disabled>
-    <option>Loading recipes…</option>
-  </select>
-  <dl>
-    <dt>Model</dt>
-    <dd data-cookbook-model>Loading…</dd>
-    <dt>Source</dt>
-    <dd><a data-cookbook-source href="../inference/examples/basic/">Browse maintained examples</a></dd>
-  </dl>
-  <pre><code class="language-bash" data-cookbook-command>Loading…</code></pre>
-  <p class="cookbook-picker__status" role="status" aria-live="polite" data-cookbook-status></p>
-  <noscript>
-    JavaScript is needed for the recipe picker. Browse the
-    <a href="../inference/examples/examples_inference_index/">inference examples</a>
-    instead.
-  </noscript>
-</div>
-
-## Customize a recipe
-
-Start from the checked-in source, then change only the settings your model
-supports:
-
-- [Configuration](../inference/configuration.md) covers the Python and CLI
-  config surfaces.
-- [Optimizations](../inference/optimizations.md) covers attention backends,
-  compilation, and memory tradeoffs.
-- [Support matrix](../inference/support_matrix.md) lists supported models and
-  optimizations.

docs/design/apple_silicon_fast_mode.md

@@ -1,129 +0,0 @@
-# Fast mode (RIFE) — Apple Silicon
-
-`--fast` makes local generation ~2.7× faster by **generating fewer frames and
-interpolating the rest** with an Apple-Silicon-native RIFE model, instead of
-denoising every frame. Video-diffusion denoise is dominated by self-attention,
-which is O(tokens²); halving the frames cuts the token count ~2× and the denoise
-compute ~3.7×, so the wall-clock drops far more than 2×. RIFE (which estimates
-its own optical flow — no motion vectors needed) fills the dropped frames back
-in for ~1.4 s, and a light unsharp pass counters its softening.
-
-Measured on the 1.3B INT8 QAD model (480×832×81, M4): generate 41 + RIFE→81
-runs in ~35 s of denoise vs ~90 s full, at reconstruction MS-SSIM **0.97**.
-Reproduce with `python -m fastvideo.benchmarks.eval_metalfx_rife --mode int8`.
-
-> **Note:** Apple's *MetalFX* frame interpolation is **not** usable here — it
-> requires game-engine motion vectors + depth, which diffusion output lacks. We
-> use the video-native **`rife-mlx`** model instead (Metal-backed, torch-free).
-
-## Install
-
-```bash
-uv pip install -e ".[mlx]"   # RIFE ships vendored; this only needs MLX
-```
-
-## Use
-
-```bash
-python examples/inference/basic/mlx_wan_prompt_to_video.py \
-  --model-root ./FastMetal-1.3B-QAD \
-  --mlx-checkpoint ./FastMetal-1.3B-QAD \
-  --prompt "A bird's-eye view of a misty forest valley at dawn." \
-  --num-frames 81 --fast \
-  --output-path video_samples/forest_fast.mp4
-```
-
-`--num-frames` stays the *target* length; fast mode generates the smallest
-VAE-aligned keyframe count that RIFE can interpolate to that target.
-
-| Flag | Default | Meaning |
-|---|---|---|
-| `--fast` / `--no-fast` | off | enable fast mode |
-| `--fast-factor` | 2 | generate 1/factor of the frames (2 = half) |
-| `--fast-sharpen` | 0.6 | light unsharp strength to counter RIFE softness (0 disables) |
-
-Fast mode composes with everything else (`--mlx-quantization int8`,
-`--mlx-compile`, TAEHV vs `--decode-backend wan-vae`). Keep `--fast-factor` at 2
-for quality — larger temporal gaps are where RIFE starts inventing motion.
-
-## Spatial fast mode (`--fast-spatial`)
-
-The spatial twin of `--fast`: instead of dropping frames, drop pixels. Denoise
-*and decode* at `height/width // fast-spatial-scale`, then resample the decoded
-frames up to the requested size. Self-attention is O(tokens²), so halving each
-spatial axis cuts the token count 4× and the denoise time far more than that —
-measured on the 1.3B INT8 QAD model at 480×832×81, M4 Max: **86.1 s → 10.3 s**
-of denoise. It composes with `--fast`; both together run the same clip in
-**4.5 s** of denoise.
-
-```bash
-python examples/inference/basic/mlx_wan_prompt_to_video.py \
-  --prompt "A bird's-eye view of a misty forest valley at dawn." \
-  --height 480 --width 832 --num-frames 81 --fast-spatial \
-  --output-path video_samples/forest_fast_spatial.mp4
-```
-
-| Flag | Default | Meaning |
-|---|---|---|
-| `--fast-spatial` / `--no-fast-spatial` | off | enable spatial fast mode |
-| `--fast-spatial-scale` | 2 | denoise at 1/scale of each spatial axis |
-| `--fast-spatial-upsample-mode` | `lanczos` | pixel interpolation kernel (`lanczos`, `cubic`, `bilinear`, `nearest`) |
-| `--fast-spatial-sharpen` | 0.4 | light unsharp strength to counter resampling softness (0 disables) |
-
-### The upsample must happen in pixel space
-
-This is the one thing to get right. The obvious implementation — bilinearly
-upsample the finished latents and decode at the target size — **does not work**,
-and produces a distinctive failure: correct composition and silhouette under a
-smeared, hazy veil, with ringing along strong edges.
-
-A Wan latent cell is a *learned code* for an 8×8 (Wan2.1) or 16×16 (Wan2.2)
-pixel block, not a low-pass sample of the image. The average of two adjacent
-codes is not the code of the averaged blocks; it is a vector the decoder was
-never trained on. Measured on Wan2.1-1.3B at 480×832, a 2× bilinear latent
-upsample destroys **62%** of the latent's high-frequency energy while leaving
-its overall magnitude intact — exactly the signature of that veil. At Wan2.2-5B
-the same operation degrades to black or noise.
-
-Decoded RGB frames have no such problem: an image *is* a sampled 2-D signal, so
-Lanczos interpolation is the operation it was defined for. The result is soft —
-it carries stage-1's real detail budget and no more — but clean and coherent.
-
-`--refine` gets away with a latent-space upsample only because a second DMD pass
-re-denoises the hand-off; spatial fast mode passes the latent straight to the
-decoder, so it cannot.
-
-## Refine (`--refine`) stage-2 timesteps
-
-`--refine` hands stage 1 to stage 2 as `(1 - sigma) * upsampled + sigma * noise`,
-where `sigma` comes from the *first* stage-2 timestep. FastWan's DMD grid opens
-at `t=1000`, which is `sigma == 1` exactly — so a stage-2 grid that starts there
-weights the stage-1 result at zero and refine silently degrades into a plain
-full-resolution run at twice the cost.
-
-Left unset, `--refine-dmd-denoising-steps` now derives the stage-2 grid from the
-stage-1 one with leading full-noise steps dropped (`1000,757,522` → `757,522`).
-That keeps the pass on timesteps the distilled student was trained on while
-letting stage-1 structure through: hand-off `sigma = 0.757`, stage-1 weight
-`0.243`. Passing a grid that starts at full noise is now an error rather than a
-silently wasted pass.
-
-The run prints the resolved hand-off so it is visible:
-
-```
-[refine] stage-2 hand-off sigma=0.7568 (stage-1 weight 0.2432)
-```
-
-There is a trade-off in choosing that grid. Later start = more of the draft
-survives, but fewer stage-2 steps. On Wan2.1 the default `757,522` gives weight
-0.243 with two steps; `--refine-dmd-denoising-steps 522` gives weight 0.478 with
-one. `--refine-sigma` decouples the noise level from the timestep entirely — it
-logs a warning, because the DiT is then told a timestep that does not match the
-noise it receives.
-
-**Wan2.2-5B has a lower ceiling.** Its warped schedule maps `1000,757,522` to
-sigmas `1.000, 0.940, 0.845`, so the best available stage-1 weight is **0.060**
-(vs 0.243 at 1.3B). Un-warped (`--no-warp`) the same grid gives `1.000, 0.757,
-0.522` and a weight of 0.243 — but warping is what matches the FastVideo
-sampling schedule, so turning it off changes the timesteps the distilled student
-sees. Which is better at 5B is unresolved and needs a run on real 5B weights.

docs/design/inference_schema_parity_inventory.yaml

@@ -21,8 +21,6 @@ surfaces:
       hsdp_shard_dim: generator.engine.parallelism.hsdp_shard_dim
       dist_timeout: generator.engine.parallelism.dist_timeout
       lora_path: generator.pipeline.components.lora_path
-      lora_nickname: generator.pipeline.components.lora_nickname
-      lora_strength: generator.pipeline.components.lora_strength
       dit_cpu_offload: generator.engine.offload.dit
       use_fsdp_inference: generator.engine.use_fsdp_inference
       dit_layerwise_offload: generator.engine.offload.dit_layerwise
@@ -74,14 +72,10 @@ surfaces:
     compatibility_only:
       mode: "Legacy multi-mode FastVideoArgs switch; typed inference config should not expose execution mode."
       inference_mode: "Legacy boolean mirror of mode; kept only through adapters while FastVideoArgs remains."
+      lora_nickname: "Legacy adapter-selection surface pending LoRA API cleanup."
       lora_target_modules: "Legacy LoRA configuration surface pending dedicated component API."
       output_type: "Legacy output formatting surface pending GenerationResult cleanup."
       VSA_sparsity: "Model-specific inference optimization not yet represented in the typed public schema."
-      VSA_tile_size: "VSA-H3 tile geometry request; model-specific optimization not yet represented in the typed public schema."
-      inference_torch_compile: "Regional inference compile opt-in currently carried through PipelineSelection.experimental rather than CompileConfig."
-      vae_parallel_decode: "MiniMax-H3 sequence-parallel VAE decode opt-in; model-specific optimization not yet represented in the typed public schema."
-      vae_parallel_encode: "MiniMax-H3 sequence-parallel reference VAE encode opt-in; model-specific optimization not yet represented in the typed public schema."
-      vae_parallel_decode_strategy: "Chunk-transport collective for vae_parallel_decode; model-specific optimization not yet represented in the typed public schema."
       attention_backend: "Process-wide default attention-backend request applied per component at load time; kernel-selection knob not yet represented in the typed public schema."
       moba_config_path: "Model-specific MoBA optimization surface not yet represented in the typed public schema."
       master_port: "Executor/bootstrap compatibility field; not part of the canonical inference schema."
@@ -125,14 +119,12 @@ surfaces:
       vae_precision: "Precision override pending dedicated typed component precision design."
       vae_decode_precision: "Decode-only precision override pending dedicated typed component precision design."
       image_encoder_precision: "Precision override pending dedicated typed component precision design."
-      image_encoder_precisions: "Precision overrides pending dedicated typed component precision design."
       text_encoder_precisions: "Precision override pending dedicated typed component precision design."
     internal_only:
       dit_config: "Legacy internal component config object."
       upsampler_config: "Legacy internal component config object."
       vae_config: "Legacy internal component config object."
       image_encoder_config: "Legacy internal component config object."
-      image_encoder_configs: "Legacy internal component config objects."
       text_encoder_configs: "Legacy internal component config object."
       preprocess_text_funcs: "Internal text preprocessing hooks."
       postprocess_text_funcs: "Internal text postprocessing hooks."
@@ -369,30 +361,6 @@ surfaces:
         sources: [fastvideo.configs.pipelines.matrixgame2.MatrixGame2I2V480PConfig]
       num_frames_per_block:
         sources: [fastvideo.configs.pipelines.matrixgame2.MatrixGame2I2V480PConfig]
-      duration_s:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      spectrogram_frame_rate:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      latent_downsample_rate:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      clip_frame_rate:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      sync_frame_rate:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      sync_segment_size:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      sync_segment_stride:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      sync_downsample_rate:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      clip_image_size:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      sync_image_size:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      clip_batch_size_multiplier:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
-      sync_batch_size_multiplier:
-        sources: [fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig]
       audio_channels:
         sources:
           - fastvideo.configs.pipelines.stable_audio.StableAudioT2AConfig
@@ -407,7 +375,6 @@ surfaces:
           - fastvideo.configs.pipelines.stable_audio.StableAudioOpenSmallConfig
       max_audio_duration_s:
         sources:
-          - fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig
           - fastvideo.configs.pipelines.stable_audio.StableAudioT2AConfig
           - fastvideo.configs.pipelines.stable_audio.StableAudioOpenSmallConfig
       sample_size:
@@ -416,7 +383,6 @@ surfaces:
           - fastvideo.configs.pipelines.stable_audio.StableAudioOpenSmallConfig
       sampling_rate:
         sources:
-          - fastvideo.configs.pipelines.mmaudio.MMAudioV2AConfig
           - fastvideo.configs.pipelines.stable_audio.StableAudioT2AConfig
           - fastvideo.configs.pipelines.stable_audio.StableAudioOpenSmallConfig
       audio_txt_guidance_scale:
@@ -591,31 +557,15 @@ surfaces:
   openai_video_request:
     kept:
       model: "HTTP adapter model-routing field."
-      user: "OpenAI-compatible caller tracking field."
-      task: "SGLang-compatible MiniMax-H3 task selector validated against the startup pipeline."
-      quality: "vLLM-Omni-compatible quality-intent field; model-specific."
-      lora: "vLLM-Omni-compatible selector for the adapter fixed at server startup."
     moved:
       prompt: request.prompt
       input_reference: request.inputs.image_path
       reference_url: request.inputs.image_path
-      image_reference: request.inputs.image_path,last_image,references
-      video_reference: request.inputs.video_path,references
-      audio_reference: request.inputs.references
-      video_path: request.inputs.video_path
-      video_url: request.inputs.video_path
-      video_params: request.sampling.width,height,num_frames,fps
       size:
         target: request.sampling.width,height
         note: "Adapter parses OpenAI size strings as WIDTHxHEIGHT and forwards width then height."
-      width: request.sampling.width
-      height: request.sampling.height
       fps: request.sampling.fps
       num_frames: request.sampling.num_frames
-      aspect_ratio: request.sampling.width,height
-      short_edge: request.sampling.width,height
-      num_outputs_per_prompt: request.sampling.num_videos_per_prompt
-      n: request.sampling.num_videos_per_prompt
       seed: request.sampling.seed
       num_inference_steps: request.sampling.num_inference_steps
       guidance_scale: request.sampling.guidance_scale
@@ -623,21 +573,11 @@ surfaces:
       true_cfg_scale: request.sampling.true_cfg_scale
       negative_prompt: request.negative_prompt
       enable_teacache: request.runtime.enable_teacache
-      max_sequence_length: request.sampling.max_sequence_length
-      boundary_ratio: request.sampling.boundary_ratio
-      extra_params: request.extensions
+      output_path: request.output.output_path
     compatibility_only:
       seconds:
         target: request.sampling.num_frames
         note: "HTTP adapter duration convenience field. If num_frames is omitted, the adapter computes num_frames = fps * seconds."
-      start_time_seconds: "vLLM-Omni reference-video offset; rejected by pipelines that cannot represent it."
-      flow_shift: "vLLM-Omni request field; accepted only when the selected model exposes a matching request parameter."
-      generate_sound: "vLLM-Omni audio-output intent; accepted only by models with a matching request parameter."
-      sound_duration: "vLLM-Omni audio-duration intent; accepted only by models with a matching request parameter."
-      enable_frame_interpolation: "vLLM-Omni post-processing field; unavailable until FastVideo exposes a frame-interpolation stage."
-      frame_interpolation_exp: "vLLM-Omni post-processing field; unavailable until FastVideo exposes a frame-interpolation stage."
-      frame_interpolation_scale: "vLLM-Omni post-processing field; unavailable until FastVideo exposes a frame-interpolation stage."
-      frame_interpolation_model_path: "vLLM-Omni post-processing field; unavailable until FastVideo exposes a frame-interpolation stage."
 
 cli:
   notes:

docs/design/server_contracts/openai.md

@@ -1,170 +1,116 @@
-# OpenAI-compatible HTTP contract
+# OpenAI-compatible HTTP Contract
 
-FastVideo exposes one model-agnostic REST engine for image and video models.
-Launch it from a typed serve config:
-
-```bash
-fastvideo serve --config examples/serving/openai_fasth3.yaml
-```
-
-All generation routes share one serialized engine. FastVideo pipelines mutate
-per-request sampling state, and some adapters merge weights at load time, so a
-single loaded pipeline is never entered concurrently by image and video
-requests. HTTP handling and job polling remain asynchronous.
+The stateless FastVideo HTTP server lives at
+[`fastvideo/entrypoints/openai/`](https://github.com/hao-ai-lab/FastVideo/tree/main/fastvideo/entrypoints/openai).
+Launch: `fastvideo serve --config serve.yaml`.
 
 ## Endpoints
 
 | Method | Path | Description |
 | --- | --- | --- |
-| `GET` | `/v1/models` | List the served model and optional startup adapter |
-| `GET` | `/v1/models/{model}` | Retrieve one served model card |
-| `POST` | `/v1/videos` | Submit an asynchronous video job |
-| `POST` | `/v1/videos/sync` | Generate and return an MP4 response directly |
-| `GET` | `/v1/videos` | List in-memory jobs with `after`, `limit`, and `order` |
-| `GET` | `/v1/videos/{id}` | Retrieve job status and metadata |
-| `GET` | `/v1/videos/{id}/content` | Download a completed MP4 |
-| `DELETE` | `/v1/videos/{id}` | Delete a job and its completed artifact |
-| `POST` | `/v1/images` | Generate an image |
-| `POST` | `/v1/images/edits` | Generate an image from image references |
-| `GET` | `/v1/images/{id}/content` | Download a generated image |
+| `POST` | `/v1/videos/generations` | Synchronous video generation |
+| `GET` | `/v1/videos` | List prior jobs held in the in-memory store |
+| `GET` | `/v1/videos/{id}` | Job status / result |
+| `GET` | `/v1/videos/{id}/content` | Download the MP4 once ready |
+| `POST` | `/v1/images/generations` | Synchronous image generation |
+| `GET` | `/v1/models` | Enumerate registered models |
 | `GET` | `/health` | Liveness probe |
 
-`POST /v1/videos/generations` remains an alias for older FastVideo clients.
+## `VideoGenerationsRequest` shape
 
-## Video requests
-
-The canonical shape follows vLLM-Omni and accepts SGLang's common flat
-extensions. Fields that FastVideo cannot represent for the loaded model fail
-at admission with HTTP 400 instead of creating a job that later fails.
+Mirrors the OpenAI `POST /v1/videos/generations` shape:
 
 ```json
 {
-  "model": "fasth3",
-  "prompt": "A fox runs through fresh snow.",
-  "seconds": "5",
-  "size": "1344x768",
-  "video_params": {
-    "fps": 24,
-    "num_frames": 124
-  },
+  "prompt": "a fox running through snow",
+  "size": "1024x1536",
+  "seconds": 5,
+  "fps": 24,
+  "num_frames": 121,
   "seed": 42,
-  "num_inference_steps": 5,
+  "num_inference_steps": 8,
   "guidance_scale": 1.0,
-  "image_reference": [
-    {"image_url": "https://example.com/first-frame.png"}
-  ],
-  "extra_params": {
-    "vsa_mode": "exempt"
-  }
+  "negative_prompt": "blurry, low quality",
+  "input_reference": "/path/to/init.png"
 }
 ```
 
-Resolution precedence matches vLLM-Omni:
+SGLang-compatible extensions carried today:
+`num_inference_steps`, `guidance_scale`, `guidance_scale_2`,
+`true_cfg_scale`, `negative_prompt`, `enable_teacache`, `output_path`.
 
-1. `size`
-2. top-level `width` and `height`
-3. `video_params.width` and `video_params.height`
+## Merge precedence
 
-Top-level `fps` and `num_frames` similarly take precedence over the nested
-block. If `num_frames` is absent, `seconds * fps` is used. FastVideo also keeps
-the legacy `input_reference`, `reference_url`, `video_path`, and `video_url`
-spellings.
+The server builds a `GenerationRequest` each call using three layers,
+highest first:
 
-Reference objects support URL or local-path strings through `image_url`,
-`video_url`, and `audio_url`. `file_id` references are schema-compatible but
-return HTTP 400 because FastVideo does not provide an OpenAI Files store.
-Image URLs, data URLs, local paths, and multipart `input_reference` uploads are
-materialized and decoded under the configured output directory during
-admission. Invalid media returns HTTP 400 before a job is created.
+1. **Request body (client-explicit)** — only fields carried in
+   `request.model_fields_set` (Pydantic v2). Unset fields do not count,
+   even if the Pydantic model has a schema default for them.
+2. **`ServeConfig.default_request` (operator-explicit)** — projected via
+   [`explicit_request_updates()`](https://github.com/hao-ai-lab/FastVideo/blob/main/fastvideo/api/compat.py);
+   only fields the operator actually wrote into the YAML count as
+   defaults. Every other field inherits the schema default rather than
+   being pinned.
+3. **Hardcoded fallback** — e.g. `fps = 24`.
 
-## Jobs and synchronous responses
+The gate matters: both surfaces carry schema defaults. Without
+`model_fields_set` / explicit-path tracking, schema defaults would
+masquerade as intent and silently shadow the other side.
 
-An asynchronous submission returns a `video` object in `queued` state. Its
-status advances through `in_progress` to `completed` or `failed`. Completed
-jobs expose `file_name`, the FastVideo compatibility extension `file_path`,
-timings, and peak-memory metadata when the pipeline reports them.
+See [`video_api.py::_build_generation_kwargs`](https://github.com/hao-ai-lab/FastVideo/blob/main/fastvideo/entrypoints/openai/video_api.py)
+for the canonical implementation; the per-request assembly lives there,
+not in pipeline code.
 
-`POST /v1/videos/sync` returns `video/mp4` bytes. It includes
-`X-Request-Id`, `X-Model`, `X-Inference-Time-S`, `X-Stage-Durations`, and
-`X-Peak-Memory-MB` headers. Its temporary MP4 is removed after the response is
-streamed. Asynchronous artifacts remain available until their job is deleted.
+## Continuation state
 
-Output paths are controlled by the server. Clients cannot choose filesystem
-destinations; every video is written beneath `server.output_dir` with a unique
-request id.
+The stateless surface accepts an opaque `ContinuationState` round-trip.
+Clients that want continuation pass the prior `state` blob back on the
+next request, and receive a new one on the response when
+`request.output.return_state = true`.
 
-FastVideo's synchronous CUDA execution cannot be interrupted after launch.
-Deleting an in-progress resource removes it from the API immediately; the
-engine remains serialized until the call exits and then removes any artifact.
-
-## Model and LoRA selection
-
-`server.served_model_name` controls the public model id. If omitted, the
-checkpoint path is used. Requests that name another model fail with HTTP 400.
-
-LoRAs are configured under
-`generator.pipeline.components.{lora_path,lora_nickname,lora_strength}`. The
-startup adapter is the only model advertised by a LoRA server, and requests can
-select it by its model nickname or with a selector:
+Shape:
 
 ```json
 {
-  "prompt": "A fox runs through fresh snow.",
-  "model": "fasth3-dense-datafree",
-  "lora": {
-    "name": "fasth3-dense-datafree",
-    "path": "/models/adapter_model.safetensors",
-    "scale": 1.0
+  "state": {
+    "kind": "ltx2.v1",
+    "payload": { "schema_version": 1, "segment_index": 3, ... }
   }
 }
 ```
 
-The selector must match the adapter already loaded at startup. FastH3 adapter
-files can contain dense replacement tensors and VSA gates in addition to
-low-rank factors, so swapping them inside concurrent requests would corrupt
-shared pipeline state. A mismatch is rejected with HTTP 400.
+Payload is always JSON-serializable. Large tensors may live in an
+opaque blob-store reference the client simply round-trips; see
+[`LTX2ContinuationState`](https://github.com/hao-ai-lab/FastVideo/blob/main/fastvideo/pipelines/basic/ltx2/continuation.py).
 
-## MiniMax-H3 and FastH3
+Continuation is not yet wired all the way through to
+`generator.generate_video(...)` — PR 7.6 (GPU pool upstream) is the
+pipeline-level consumer. PR 7 locked the envelope so this surface is
+stable ahead of that plumbing.
 
-FastH3 uses the same general routes and adapter. `task` is accepted for
-SGLang-compatible H3 clients:
+## Error codes
 
-- `t2va` uses text only.
-- `fl2va` takes one or two image references.
-- `ref2va` takes ordered image, video, and audio references and requires a
-  server started with `MiniMaxH3Ref2VAModularPipeline`.
+| HTTP | Condition |
+| --- | --- |
+| `400 Bad Request` | Parse/validation failure (unknown field, type mismatch, incompatible preset/state) |
+| `404 Not Found` | `GET /v1/videos/{id}` for an unknown job |
+| `409 Conflict` | Job id already exists |
+| `500 Internal Server Error` | Pipeline raised; body mirrors upstream OpenAI error envelope |
+| `503 Service Unavailable` | No generator loaded, or shutdown in progress |
 
-The released FastH3 pipeline generates one packed video/audio result per
-request, uses 24 fps, requires guidance scale 1, and accepts frame counts on
-its causal-VAE grid. The serving examples pin its five-point distilled sigma
-schedule (four DiT forwards).
+Errors include a JSON body with
+`{"error": {"type": "...", "message": "..."}}` matching the OpenAI
+Python SDK's expectation.
 
-## Defaults and errors
+## What does not cross this boundary
 
-Incoming explicit fields override operator-explicit `default_request` fields,
-which override model preset defaults. Pydantic defaults do not masquerade as
-client intent; the transport uses `model_fields_set`, while typed config parsing
-tracks the exact paths written by the operator.
-
-Errors use the OpenAI envelope:
-
-```json
-{
-  "error": {
-    "message": "...",
-    "type": "invalid_request_error",
-    "param": null,
-    "code": 400
-  }
-}
-```
-
-Parse, model-selection, startup-LoRA, and unsupported-parameter failures are
-HTTP 400; missing resources are HTTP 404; generation failures are stored on
-asynchronous jobs and returned as HTTP 500 when that job is retrieved.
-Unknown top-level fields are rejected. `extra_params` accepts only the explicit
-request-batch passthrough fields supported by the typed request adapter.
-
-`GET /health` also verifies that the generation engine is open and all local
-multiprocess workers are alive. It returns HTTP 503 when the worker pool is no
-longer usable.
+* Flat legacy kwargs (`ltx2_refine_enabled`, `torch_compile_kwargs`,
+  etc.) — these are init-time, configured via `ServeConfig.generator`,
+  never per-request.
+* Private Dreamverse-only fields — those live in a private adapter on
+  the Dreamverse side; the public FastVideo surface never promises
+  backward compatibility for them.
+* Raw tensor payloads (`ltx2_audio_clean_latent` et al.) — these are
+  derived by the pipeline from `ContinuationState`, never shipped as
+  request fields.