freesolo-flash-dev 1.0.2__tar.gz → 1.0.4__tar.gz

{freesolo_flash_dev-1.0.2 → freesolo_flash_dev-1.0.4}/.github/workflows/bake-kernel-cache.yml

@@ -22,7 +22,7 @@ on:
     inputs:
       sms:
         description: "comma-separated sm list to bake; default is all validated arches"
-        default: "sm80,sm86,sm89,sm90,sm120"
+        default: "sm80,sm86,sm89,sm90,sm120,sm100"
         required: false
   # auto-rebake.yml calls this for the EXPENSIVE path (the cache is invalid and must be re-warmed on a
   # real GPU). It passes the arch subset, the fingerprints to stamp, and a digest-pinned base so the
@@ -105,10 +105,9 @@ jobs:
               gpu_type_id: "NVIDIA RTX PRO 6000 Blackwell Server Edition",
               allowed_cuda: "13.0",
             }
-          # Datacenter Blackwell (sm100, distinct from the sm120 RTX Pro 6000). B200 has 180 GB and
-          # good secure-cloud capacity. CUDA-13 host like the other Blackwell parts. NOT in the default
-          # `sms` list yet (B200 is unvalidated) -- bake it explicitly via `sms=sm100` until a smoke
-          # passes, then add it to the default.
+          # datacenter blackwell (sm100, distinct from the sm120 rtx pro 6000). b200 has 180 gb,
+          # good secure-cloud capacity, and is validated. promote its image only after a successful
+          # real-b200 bake, then include it in default and automatic rebakes.
           - {
               sm: sm100,
               arch: "10.0",
@@ -120,7 +119,7 @@ jobs:
       - name: Should bake ${{ matrix.sm }}?
         id: gate
         run: |
-          req="${{ inputs.sms || 'sm80,sm86,sm89,sm90,sm120' }}"
+          req="${{ inputs.sms || 'sm80,sm86,sm89,sm90,sm120,sm100' }}"
           req="${req// /}"   # tolerate spaces, e.g. "sm80, sm86"
           case ",$req," in
             *,${{ matrix.sm }},*) echo "run=true" >> "$GITHUB_OUTPUT" ;;

{freesolo_flash_dev-1.0.2 → freesolo_flash_dev-1.0.4}/Dockerfile.worker

@@ -55,7 +55,7 @@ RUN pip install --no-cache-dir \
     "flashinfer-python==0.6.6" \
     "bitsandbytes>=0.49" \
     "datasets>=4.7,<6" \
-    "huggingface_hub>=0.25" \
+    "huggingface_hub>=1.2.0" \
     "accelerate>=1.4" \
     "wandb>=0.17" \
     "flash-linear-attention @ git+https://github.com/fla-org/flash-linear-attention.git@f0e213dbd8b5fb90c3c7eca869ac1706d5377139" \

{freesolo_flash_dev-1.0.2 → freesolo_flash_dev-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 1.0.2
+Version: 1.0.4
 Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash
@@ -20,7 +20,7 @@ Requires-Dist: datasets>=2.19; extra == 'dev'
 Requires-Dist: fastapi; extra == 'dev'
 Requires-Dist: freesolo>=0.2.54; extra == 'dev'
 Requires-Dist: httpx>=0.27; extra == 'dev'
-Requires-Dist: huggingface-hub>=0.34; extra == 'dev'
+Requires-Dist: huggingface-hub>=1.2.0; extra == 'dev'
 Requires-Dist: jsonschema>=4.23; extra == 'dev'
 Requires-Dist: mypy>=1.13.0; extra == 'dev'
 Requires-Dist: pytest>=9.0.3; extra == 'dev'
@@ -35,7 +35,7 @@ Requires-Dist: accelerate>=1.4; extra == 'gpu'
 Requires-Dist: bitsandbytes>=0.49; extra == 'gpu'
 Requires-Dist: datasets>=2.19; extra == 'gpu'
 Requires-Dist: freesolo>=0.2.54; extra == 'gpu'
-Requires-Dist: huggingface-hub>=0.34; extra == 'gpu'
+Requires-Dist: huggingface-hub>=1.2.0; extra == 'gpu'
 Requires-Dist: peft>=0.19; extra == 'gpu'
 Requires-Dist: torch==2.10.0; extra == 'gpu'
 Requires-Dist: transformers<5.11,>=5.6; extra == 'gpu'
@@ -46,7 +46,7 @@ Requires-Dist: datasets>=2.19; extra == 'server'
 Requires-Dist: fastapi; extra == 'server'
 Requires-Dist: freesolo>=0.2.54; extra == 'server'
 Requires-Dist: httpx>=0.27; extra == 'server'
-Requires-Dist: huggingface-hub>=0.34; extra == 'server'
+Requires-Dist: huggingface-hub>=1.2.0; extra == 'server'
 Requires-Dist: jsonschema>=4.23; extra == 'server'
 Requires-Dist: referencing>=0.28.4; extra == 'server'
 Requires-Dist: regex>=2024.11.6; extra == 'server'

{freesolo_flash_dev-1.0.2 → freesolo_flash_dev-1.0.4}/flash/catalog.py

@@ -13,6 +13,22 @@ ALGORITHMS = ("sft", "grpo", "opd")
 # the cost model, VRAM sizing and worker allocator branch on — import ``samples_on_policy`` instead
 # of hand-rolling the ("grpo", "opd") tuple at each site.
 _ON_POLICY_ALGORITHMS = frozenset({"grpo", "opd"})
+_IMAGE_TRAINING_MODELS = frozenset(
+    {
+        "Qwen/Qwen3.5-0.8B",
+        "Qwen/Qwen3.5-2B",
+        "Qwen/Qwen3.5-4B",
+        "Qwen/Qwen3.5-9B",
+        "Qwen/Qwen3.6-27B",
+        "Qwen/Qwen3.6-35B-A3B",
+    }
+)
+
+
+def supports_image_training(model: str | ModelInfo | None) -> bool:
+    """Return whether a curated model supports image-bearing SFT, GRPO, and OPD."""
+    model_id = model.id if isinstance(model, ModelInfo) else model
+    return bool(model_id and model_id in _IMAGE_TRAINING_MODELS)
 
 
 def samples_on_policy(algorithm: str) -> bool:
@@ -146,10 +162,10 @@ class ModelInfo:
 
 DEFAULT_MODEL = "Qwen/Qwen3.5-4B"
 
-# The pre-quantized FP8 checkpoint each base model's serving engine LOADS (mirrors serving's
-# ``src.prequant_config``). Every dense model now serves a Freesolo-OWNED FP8_DYNAMIC checkpoint (no
-# community-repo dependence); the 35B VL MoE serves the OFFICIAL Qwen FP8 (it preserves the full
-# vision-language model). Informational for the catalog mirror — deploy gating reads only max_lora_rank.
+# the pre-quantized fp8 checkpoint each base model's serving engine loads (mirrors serving's
+# ``src.prequant_config``). every dense model serves a freesolo-owned fp8 checkpoint; the qwen3.6
+# 35b-a3b moe serves the official qwen fp8 variant. informational for the catalog mirror; deploy
+# gating reads only max_lora_rank.
 SERVING_FP8_MODEL_REPOS: dict[str, str] = {
     "openbmb/MiniCPM5-1B": "Freesolo-Co/MiniCPM5-1B-FP8",
     "Qwen/Qwen3.5-0.8B": "Freesolo-Co/Qwen3.5-0.8B-FP8",
@@ -157,6 +173,7 @@ SERVING_FP8_MODEL_REPOS: dict[str, str] = {
     "Qwen/Qwen3.5-4B": "Freesolo-Co/Qwen3.5-4B-FP8",
     "Qwen/Qwen3.5-9B": "Freesolo-Co/Qwen3.5-9B-FP8",
     "Qwen/Qwen3.6-35B-A3B": "Qwen/Qwen3.6-35B-A3B-FP8",
+    "Qwen/Qwen3.6-27B": "Freesolo-Co/Qwen3.6-27B-FP8",
 }
 
 MODELS: dict[str, ModelInfo] = {
@@ -182,7 +199,7 @@ MODELS: dict[str, ModelInfo] = {
     "Qwen/Qwen3.5-0.8B": ModelInfo(
         id="Qwen/Qwen3.5-0.8B",
         display_name="Qwen3.5 0.8B",
-        params="0.9B (text-only fine-tune)",
+        params="0.9B",
         params_b=0.9,
         vocab_size=248_320,
         algos=ALGORITHMS,
@@ -201,7 +218,7 @@ MODELS: dict[str, ModelInfo] = {
     "Qwen/Qwen3.5-2B": ModelInfo(
         id="Qwen/Qwen3.5-2B",
         display_name="Qwen3.5 2B",
-        params="2.3B (text-only fine-tune)",
+        params="2.3B",
         params_b=2.3,
         vocab_size=248_320,
         algos=ALGORITHMS,
@@ -219,7 +236,7 @@ MODELS: dict[str, ModelInfo] = {
     "Qwen/Qwen3.5-4B": ModelInfo(
         id="Qwen/Qwen3.5-4B",
         display_name="Qwen3.5 4B",
-        params="4.7B (text-only fine-tune)",
+        params="4.7B",
         params_b=4.7,
         vocab_size=248_320,
         algos=ALGORITHMS,
@@ -241,7 +258,7 @@ MODELS: dict[str, ModelInfo] = {
     "Qwen/Qwen3.5-9B": ModelInfo(
         id="Qwen/Qwen3.5-9B",
         display_name="Qwen3.5 9B",
-        params="9.7B (text-only fine-tune)",
+        params="9.7B",
         params_b=9.7,
         vocab_size=248_320,
         algos=ALGORITHMS,
@@ -264,6 +281,35 @@ MODELS: dict[str, ModelInfo] = {
         "(two bf16 copies + KV + the 248k-vocab fp32 logits) needs an 80 GB-class card "
         "(grpo_min_vram_gb floor).",
     ),
+    "Qwen/Qwen3.6-27B": ModelInfo(
+        id="Qwen/Qwen3.6-27B",
+        display_name="Qwen3.6 27B",
+        params="27B dense (multimodal VL, hybrid GDN)",
+        params_b=27.0,
+        num_layers=64,
+        hidden_size=5120,
+        vocab_size=248_320,
+        algos=("sft", "grpo", "opd"),
+        min_vram_gb=80,
+        sft_min_vram_gb=80,
+        quant="bf16",
+        recommended_gpu="A100 PCIe",
+        min_disk_gb=160,
+        serving=ServingCapacity(
+            gpu="H100",
+            serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.6-27B"],
+            max_loras=16,
+            max_lora_rank=64,
+            max_model_len=32768,
+            max_num_seqs=8,
+            gpu_memory_utilization=0.98,
+        ),
+        thinking="hybrid",
+        notes="Dense 27B multimodal VL checkpoint with image-capable bf16 LoRA training. SFT fits "
+        "the 80GB A100 (~54GB weights); colocated GRPO needs the B200 (trainer + vLLM rollout = two "
+        "~54GB copies). Serves the owned VL-preserving FP8 on an H100 tier (dense, so no MoE expert "
+        "LoRA-buffer multiplier).",
+    ),
     "Qwen/Qwen3.6-35B-A3B": ModelInfo(
         id="Qwen/Qwen3.6-35B-A3B",
         display_name="Qwen3.6 35B-A3B (MoE)",

{freesolo_flash_dev-1.0.2 → freesolo_flash_dev-1.0.4}/flash/cli/__init__.py

@@ -424,7 +424,11 @@ def _build_parser() -> argparse.ArgumentParser:
     deployments.set_defaults(func=cmd_deployments)
 
     chat = sub.add_parser("chat", help="chat with a deployed adapter")
-    chat.add_argument("run_id")
+    chat.add_argument(
+        "run_id",
+        help="a bare RUN_ID (its current deployment), RUN_ID/step-N (a specific deployed "
+        "checkpoint), or a full immutable adapter revision",
+    )
     chat.add_argument("-m", "--message", required=True)
     chat.add_argument(
         "--system",

{freesolo_flash_dev-1.0.2 → freesolo_flash_dev-1.0.4}/flash/cli/commands.py

@@ -160,8 +160,9 @@ def cmd_gpus(args) -> int:
         (info for info in GPU_INFO.values() if info.enum_member), key=lambda g: g.hourly_usd
     )
     tip = (
-        "Tip: GPU class selection is fully automatic — the submit-time allocator always picks the\n"
-        "cheapest validated managed class that fits the model, so you don't pin a GPU type."
+        "Tip: GPU allocation is automatic by default.\n"
+        "The allocator picks the cheapest validated class that fits. Pin a specific class by "
+        'adding exact_type = "<CLASS>" to the [gpu] section.'
     )
     if render.styled():
         rows = [(info.name, info.vram_gb, runpod_rates.get(info.name)) for info in infos]
@@ -313,9 +314,8 @@ def cmd_train(args) -> int:
         runtime_secrets_from_local_env(args.config, keys=spec.environment.secrets) or None
     )
     if args.dry_run:
-        # dry-run is a faithful server-side preview: it sends the same declared secrets and runs the
-        # same config, warm-start, serving, and cost preflights as a real submit, but allocates no gpu
-        # and charges nothing. a rejection surfaces as the server's error with exit status 1.
+        # dry-run runs submit-time server preflights without importing user code, allocating a gpu,
+        # or charging anything. a rejection surfaces as the server's error with exit status 1.
         try:
             status = client.create_run(
                 payload,
@@ -330,6 +330,14 @@ def cmd_train(args) -> int:
             raise ApiError(exc.status, detail) from exc
         compatibility = status.pop("train_schema_compatibility", None)
         _print_train_schema_compatibility(compatibility)
+        print(
+            "dry-run validated: config/schema, model+algorithm compatibility, lora rank, "
+            "runtime-secret presence, warm-start source, serving context cap, and cost. it did NOT "
+            "import or run your environment.py; dataset loading, start_episode/episode shapes, "
+            "reward/scorer, worker imports, model load, and gpu/training are first exercised on the "
+            "worker after cold-start.",
+            file=sys.stderr,
+        )
         if render.styled():
             print(
                 render.object_panel(
@@ -376,18 +384,26 @@ def _log_follow_progress(status: dict | None, fallback_state: str) -> tuple[str,
     parts = [state]
     heartbeat = status.get("last_heartbeat") if isinstance(status, dict) else None
     if isinstance(heartbeat, dict):
+        heartbeat_age_seconds = render._heartbeat_age_seconds(heartbeat.get("ts"))
         stage = heartbeat.get("stage")
         if stage:
             parts.append(f"stage={stage}")
+            if state == "running":
+                warmup = render.warmup_message(
+                    stage,
+                    heartbeat_age_seconds,
+                    render.heartbeat_is_current_attempt(status, heartbeat),
+                )
+                if warmup:
+                    parts.append(warmup)
         step = heartbeat.get("step")
         if step is not None:
             parts.append(f"step={step}")
         # live heartbeat age so a long quiet phase reads as "alive, throttled" not "frozen".
         # minute granularity: the non-TTY follow path prints a line whenever this string changes,
         # so a seconds-precision age would emit one line per poll.
-        ts = heartbeat.get("ts")
-        if isinstance(ts, (int, float)) and ts > 0:
-            mins = int(max(0.0, time.time() - ts) // 60)
+        if heartbeat_age_seconds is not None:
+            mins = int(heartbeat_age_seconds // 60)
             parts.append(f"hb={mins}m" if mins else "hb=<1m")
     realized = status.get("realized_cost_usd")
     if realized is not None:
@@ -700,7 +716,7 @@ def cmd_deployments(args) -> int:
         return 0
     print(
         f"{'RUN ID':<30}  {'STEP':<6}  {'REVISION':<40}  {'STATE':<14}  "
-        f"{'VERIFIED AT':<18}  {'OPENAI MODEL':<30}  DETAIL"
+        f"{'VERIFIED AT':<20}  {'OPENAI MODEL':<30}  DETAIL"
     )
     for row in rows:
         deployment = row.get("deployment") or {}
@@ -708,14 +724,16 @@ def cmd_deployments(args) -> int:
         step = deployment.get("checkpoint_step")
         step_text = "final" if step is None else str(step)
         verified_at = deployment.get("verified_at")
-        verified_text = "-" if verified_at is None else str(verified_at)
+        verified_text = (
+            "-" if verified_at is None else (render._humanize_ts(verified_at) or str(verified_at))
+        )
         revision = str(deployment.get("adapter_revision") or "-")
         state = str(deployment.get("state") or "-")
         openai_model = str(deployment.get("openai_model") or run_id)
         detail = str(deployment.get("error") or deployment.get("detail") or "")[:160]
         print(
             f"{run_id:<30}  {step_text:<6}  {revision:<40}  {state:<14}  "
-            f"{verified_text:<18}  {openai_model:<30}  {detail}"
+            f"{verified_text:<20}  {openai_model:<30}  {detail}"
         )
     return 0
 
@@ -728,18 +746,11 @@ def cmd_chat(args) -> int:
     if revision is None and parsed is None:
         print(
             f"invalid chat target {args.run_id!r} "
-            "(expected a bare <run_id> or full immutable adapter revision)",
-            file=sys.stderr,
-        )
-        return 1
-    if revision is None and parsed[1] is not None:
-        print(
-            "RUN_ID/step-N is not a valid chat target because it would route through the mutable "
-            "run alias; use the full immutable adapter revision returned by `flash deployments`",
+            "(expected a bare <run_id>, <run_id>/step-N, or full immutable adapter revision)",
             file=sys.stderr,
         )
         return 1
-    chat_target = args.run_id if revision is not None else parsed[0]
+    chat_target = args.run_id
     client = client_from_config()
     messages = [{"role": "user", "content": args.message}]
     system = getattr(args, "system", None)

{freesolo_flash_dev-1.0.2 → freesolo_flash_dev-1.0.4}/flash/cli/envpush.py

@@ -11,6 +11,7 @@ import os
 import re
 import sys
 import tempfile
+from collections.abc import Iterator
 from pathlib import Path
 from typing import TYPE_CHECKING, Literal, TypeAlias
 
@@ -174,6 +175,10 @@ def cmd_env_delete(args) -> int:
 
 
 _ENV_ENTRYPOINT = "environment.py"
+_ENV_SYSPATH_BOOTSTRAP = (
+    "import os as _flash_os, sys as _flash_sys\n"
+    "_flash_sys.path.insert(0, _flash_os.path.dirname(__file__))\n"
+)
 _ENV_PUSH_IGNORED_NAMES = frozenset(
     {
         ".prime",
@@ -183,26 +188,47 @@ _ENV_PUSH_IGNORED_NAMES = frozenset(
         ".venv",
         ".mypy_cache",
         ".pytest_cache",
-        "pyproject.toml",
-        "source",
+        ".ruff_cache",
+        ".idea",
+        ".vscode",
+        ".ds_store",
+        ".git-worktrees",
+        ".env",
+        ".netrc",
+        ".aws",
+        ".ssh",
+        "venv",
+        "node_modules",
+        "credentials",
+        "secrets",
     }
 )
-# ``.md`` is included so the ``TRAINING.md`` playbook `flash env setup` scaffolds (and any
-# user-authored README/NOTES) travels with the env into the hub and back out through
-# ``flash env pull`` — a published env should carry its own training guidance, not just code+data.
-_ENV_PUSH_SIDECAR_SUFFIXES = frozenset(
-    {
-        ".csv",
-        ".json",
-        ".jsonl",
-        ".md",
-        ".parquet",
-        ".tsv",
-        ".txt",
-        ".yaml",
-        ".yml",
-    }
+_ENV_PUSH_ROOT_IGNORED_NAMES = frozenset({"pyproject.toml", "source"})
+_ENV_PUSH_SECRET_PATTERNS = (
+    ".env.*",
+    "*.env",
+    "*.pem",
+    "*.key",
+    "*.pfx",
+    "*.p12",
+    "credentials*",
+    "id_rsa*",
+    "id_dsa*",
+    "id_ecdsa*",
+    "id_ed25519*",
 )
+# secret patterns match secret data FILES only (see _ignore_env_push_path): they never prune a
+# directory, so a package tree like credentials_store/ still ships, and python source is exempt,
+# so helper modules like credentials.py or id_ed25519_loader.py travel instead of being silently
+# dropped and breaking the worker with ModuleNotFoundError. that keeps the prefixes broad enough
+# to catch backup variants (credentials_backup, id_rsa_backup) without eating code or packages.
+_ENV_PUSH_CODE_SUFFIXES = frozenset({".py", ".pyi"})
+_ENV_PUSH_MAX_TOTAL_BYTES = 256 * 1024 * 1024
+
+try:
+    from flash.envs.archive_policy import ARCHIVE_MEMBER_LIMIT as _ENV_PUSH_MAX_FILES
+except ImportError:
+    _ENV_PUSH_MAX_FILES = 5000
 
 
 def _normalize_env_name(raw: str) -> str | None:
@@ -227,16 +253,12 @@ def _normalize_env_name(raw: str) -> str | None:
 
 def _with_syspath_bootstrap(env_source: str) -> str:
     """Prepend a sys.path bootstrap so a published env can resolve shipped sibling helpers."""
-    bootstrap = (
-        "import os as _flash_os, sys as _flash_sys\n"
-        "_flash_sys.path.insert(0, _flash_os.path.dirname(__file__))\n"
-    )
     import ast
 
     try:
         tree = ast.parse(env_source)
     except SyntaxError:
-        return bootstrap + env_source
+        return _ENV_SYSPATH_BOOTSTRAP + env_source
     insert_after = 0
     body = tree.body
     i = 0
@@ -252,7 +274,16 @@ def _with_syspath_bootstrap(env_source: str) -> str:
         insert_after = body[i].end_lineno or insert_after
         i += 1
     lines = env_source.splitlines(keepends=True)
-    return "".join(lines[:insert_after]) + bootstrap + "".join(lines[insert_after:])
+    return (
+        "".join(lines[:insert_after])
+        + _ENV_SYSPATH_BOOTSTRAP
+        + "".join(lines[insert_after:])
+    )
+
+
+def _raise_walk_error(error: OSError) -> None:
+    """fail env packaging loudly instead of silently skipping an unreadable directory."""
+    raise error
 
 
 def _tar_b64(directory: Path) -> str:
@@ -266,44 +297,130 @@ def _tar_b64(directory: Path) -> str:
     with tarfile.open(fileobj=buf, mode="w:gz") as tar:
         for root, dirs, files in os.walk(directory):
             root_path = Path(root)
-            dirs[:] = sorted(d for d in dirs if d not in _ENV_PUSH_IGNORED_NAMES)
-            for name in dirs:
-                child = root_path / name
-                tar.add(child, arcname=str(child.relative_to(directory)), recursive=False)
+            dirs[:] = sorted(d for d in dirs if d.lower() not in _ENV_PUSH_IGNORED_NAMES)
             for name in sorted(files):
                 child = root_path / name
                 tar.add(child, arcname=str(child.relative_to(directory)), recursive=False)
     return base64.b64encode(buf.getvalue()).decode()
 
 
-def _copy_env_sidecars(env_root: Path, dest: Path, *, entrypoint: Path) -> None:
-    """Copy helper code and data sidecars beside environment.py."""
-    import shutil
+def _ignore_env_push_path(path: Path, *, env_root: Path, entrypoint: Path) -> bool:
+    """Return whether a source path must not be included in an env package."""
+    import fnmatch
+
+    name = path.name
+    lowered_name = name.lower()
+    if path.is_symlink():
+        return True
+    if path.is_dir() and (path / "pyvenv.cfg").is_file():
+        return True
+    if path == entrypoint or (
+        path.parent == env_root and lowered_name == _ENV_ENTRYPOINT.lower()
+    ):
+        return True
+    if lowered_name.startswith(".") or lowered_name in _ENV_PUSH_IGNORED_NAMES:
+        return True
+    if path.parent == env_root and lowered_name in _ENV_PUSH_ROOT_IGNORED_NAMES:
+        return True
+    if (
+        path.is_file()
+        and path.suffix.lower() not in _ENV_PUSH_CODE_SUFFIXES
+        and any(fnmatch.fnmatchcase(lowered_name, pattern) for pattern in _ENV_PUSH_SECRET_PATTERNS)
+    ):
+        return True
+    return not (path.is_dir() or path.is_file())
+
+
+def _iter_env_sidecar_files(
+    env_root: Path, *, entrypoint: Path, include_full_tree: bool
+) -> Iterator[tuple[Path, Path]]:
+    """Yield publishable sidecar files and their package-relative paths."""
+    import os
 
-    for child in sorted(env_root.iterdir()):
-        if (
-            child == entrypoint
-            or child.name == _ENV_ENTRYPOINT
-            or child.name in _ENV_PUSH_IGNORED_NAMES
+    roots = [env_root]
+    if not include_full_tree:
+        # a single-file push carries only the entrypoint, its dataset sidecars, and its own
+        # docs. ship user-authored docs so the synthesized stub readme does not stand in for
+        # real training guidance the user shipped next to the module.
+        for doc_name in ("README.md", "TRAINING.md"):
+            doc = env_root / doc_name
+            if doc.is_file() and not _ignore_env_push_path(
+                doc, env_root=env_root, entrypoint=entrypoint
+            ):
+                yield doc, doc.relative_to(env_root)
+        roots = [
+            env_root / name
+            for name in ("dataset", "datasets")
+            if (env_root / name).is_dir() and not (env_root / name).is_symlink()
+        ]
+
+    for walk_root in roots:
+        for root, dirs, files in os.walk(
+            walk_root, topdown=True, followlinks=False, onerror=_raise_walk_error
         ):
-            continue
-        if child.name.startswith("."):
-            continue
-        target = dest / child.name
-        if child.is_dir():
-            if child.name == "dataset":
-                shutil.copytree(
-                    child,
-                    target,
-                    ignore=shutil.ignore_patterns(*_ENV_PUSH_IGNORED_NAMES),
+            root_path = Path(root)
+            dirs[:] = sorted(
+                name
+                for name in dirs
+                if not _ignore_env_push_path(
+                    root_path / name, env_root=env_root, entrypoint=entrypoint
                 )
-            continue
-        if not child.is_file():
-            continue
-        if (
-            child.suffix == ".py" and not child.name.startswith("__")
-        ) or child.suffix.lower() in _ENV_PUSH_SIDECAR_SUFFIXES:
-            shutil.copy2(child, target)
+            )
+            for name in sorted(files):
+                child = root_path / name
+                if _ignore_env_push_path(child, env_root=env_root, entrypoint=entrypoint):
+                    continue
+                yield child, child.relative_to(env_root)
+
+
+def _check_env_push_limits(
+    env_root: Path, *, entrypoint: Path, include_full_tree: bool, env_name: str
+) -> None:
+    """Reject oversized source trees before copying or building an in-memory archive."""
+    files = 1
+    total_bytes = entrypoint.stat().st_size + len(_ENV_SYSPATH_BOOTSTRAP.encode())
+    directories: set[Path] = set()
+    has_readme = False
+    for child, relative in _iter_env_sidecar_files(
+        env_root, entrypoint=entrypoint, include_full_tree=include_full_tree
+    ):
+        files += 1
+        total_bytes += child.stat().st_size
+        has_readme = has_readme or relative == Path("README.md")
+        # the server counts every file AND directory against the same member cap when it
+        # repackages the checkout for download, so count unique parent dirs here too.
+        directories.update(parent for parent in relative.parents if parent != Path("."))
+    if not has_readme:
+        files += 1
+        total_bytes += len(f"# {env_name}\n\nFlash Freesolo environment.\n".encode())
+
+    members = files + len(directories)
+    if total_bytes > _ENV_PUSH_MAX_TOTAL_BYTES:
+        raise ValueError(
+            f"environment package totals {_human_bytes(total_bytes)} "
+            f"(limit {_human_bytes(_ENV_PUSH_MAX_TOTAL_BYTES)}); "
+            "remove large artifacts or use a smaller dataset"
+        )
+    if members > _ENV_PUSH_MAX_FILES:
+        raise ValueError(
+            f"selected environment contains {members:,} files and directories "
+            f"(limit {_ENV_PUSH_MAX_FILES:,}); "
+            "remove large artifacts or use a smaller dataset"
+        )
+
+
+def _copy_env_sidecars(
+    env_root: Path, dest: Path, *, entrypoint: Path, include_full_tree: bool
+) -> None:
+    """Copy publishable sidecar files beside environment.py, creating directories lazily."""
+    import shutil
+
+    for child, relative in _iter_env_sidecar_files(
+        env_root, entrypoint=entrypoint, include_full_tree=include_full_tree
+    ):
+        target = dest / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(child, target)
 
 
 def _human_bytes(n: int) -> str:
@@ -385,8 +502,11 @@ def cmd_env_push(args) -> int:
     src = Path(args.path)
     if not src.exists():
         return _err(f"no such path: {src}")
+    if src.is_symlink():
+        return _err(f"cannot publish {src}: symlinks are not allowed")
 
-    if src.is_dir():
+    include_full_tree = src.is_dir()
+    if include_full_tree:
         canonical_entrypoint = src / _ENV_ENTRYPOINT
         if canonical_entrypoint.is_file():
             entrypoint = canonical_entrypoint
@@ -410,11 +530,29 @@ def cmd_env_push(args) -> int:
     else:
         return _err(f"cannot publish {src}: expected a Freesolo .py module or an env directory.")
 
+    if entrypoint.is_symlink():
+        return _err(f"cannot publish {entrypoint}: symlinks are not allowed")
+
+    try:
+        _check_env_push_limits(
+            env_root,
+            entrypoint=entrypoint,
+            include_full_tree=include_full_tree,
+            env_name=env_name,
+        )
+    except (OSError, ValueError) as exc:
+        return _err(f"cannot publish {src}: {exc}")
+
     with tempfile.TemporaryDirectory(prefix="flash-env-push-") as tmp:
         pkg = Path(tmp)
         module_source = entrypoint.read_text()
         (pkg / _ENV_ENTRYPOINT).write_text(_with_syspath_bootstrap(module_source))
-        _copy_env_sidecars(env_root, pkg, entrypoint=entrypoint)
+        _copy_env_sidecars(
+            env_root,
+            pkg,
+            entrypoint=entrypoint,
+            include_full_tree=include_full_tree,
+        )
         # Only synthesize a stub README when the env didn't ship its own (now carried as a
         # ``.md`` sidecar) — don't clobber a user-authored README with boilerplate.
         readme = pkg / "README.md"