cogames 0.3.65__py3-none-any.whl → 0.3.69__py3-none-any.whl

cogames/cli/submit.py

@@ -5,33 +5,28 @@ from __future__ import annotations
 import os
 import shutil
 import subprocess
+import sys
 import tempfile
 import uuid
 import zipfile
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING
 
 import httpx
 import typer
-from rich.console import Console
 
 from cogames.cli.base import console
+from cogames.cli.client import TournamentServerClient
 from cogames.cli.login import DEFAULT_COGAMES_SERVER
 from cogames.cli.policy import PolicySpec, get_policy_spec
-from metta_alo.rollout import run_single_episode
-
-if TYPE_CHECKING:
-    from cogames.cli.client import TournamentServerClient
-
 from mettagrid.config.mettagrid_config import MettaGridConfig
 from mettagrid.policy.submission import POLICY_SPEC_FILENAME, SubmissionPolicySpec
+from mettagrid.runner.episode_runner import run_episode_isolated
+from mettagrid.runner.types import EpisodeSpec
+from mettagrid.util.uri_resolvers.schemes import localize_uri, parse_uri
 
 DEFAULT_SUBMIT_SERVER = "https://api.observatory.softmax-research.net"
-
-
-def results_url_for_season(_server: str, _season: str) -> str:
-    return "https://www.softmax.com/alignmentleague"
+RESULTS_URL = "https://www.softmax.com/alignmentleague"
 
 
 @dataclass
@@ -42,277 +37,47 @@ class UploadResult:
     pools: list[str] | None = None
 
 
-def validate_paths(paths: list[str], console: Console) -> list[Path]:
-    """Validate paths are within CWD and return them as relative paths."""
+def _resolve_path_within_cwd(path_str: str, cwd: Path) -> Path:
+    """Resolve a path and return it relative to CWD. Raises if path escapes CWD."""
+    raw_path = Path(path_str).expanduser()
+    resolved = raw_path.resolve() if raw_path.is_absolute() else (cwd / raw_path).resolve()
+    if not resolved.is_relative_to(cwd):
+        console.print(f"[red]Error:[/red] Path must be within the current directory: {path_str}")
+        raise ValueError(f"Path escapes CWD: {path_str}")
+    return resolved.relative_to(cwd)
+
+
+def validate_paths(paths: list[str]) -> list[Path]:
+    """Validate paths exist and are within CWD, return them as relative paths."""
     cwd = Path.cwd().resolve()
     validated_paths = []
-
     for path_str in paths:
-        raw_path = Path(path_str).expanduser()
-
-        # Resolve the path and check it's within CWD
-        try:
-            resolved = raw_path.resolve() if raw_path.is_absolute() else (cwd / raw_path).resolve()
-            relative = resolved.relative_to(cwd)
-        except ValueError:
-            console.print(f"[red]Error:[/red] Path must be within the current directory: {path_str}")
-            raise ValueError(f"Path escapes CWD: {path_str}") from None
-
-        # Check if path exists
+        relative = _resolve_path_within_cwd(path_str, cwd)
+        resolved = cwd / relative
         if not resolved.exists():
             console.print(f"[red]Error:[/red] Path does not exist: {path_str}")
             raise FileNotFoundError(f"Path not found: {path_str}")
-
         validated_paths.append(relative)
-
     return validated_paths
 
 
-def _maybe_resolve_checkpoint_bundle_uri(policy: str) -> tuple[Path, bool] | None:
-    """Return (local_zip_path, cleanup) if policy points to a checkpoint bundle URI."""
-    from mettagrid.policy.prepare_policy_spec import download_policy_spec_from_s3_as_zip
-    from mettagrid.util.uri_resolvers.schemes import parse_uri, resolve_uri
-
-    first = policy.split(",", 1)[0].strip()
-    parsed = parse_uri(first, allow_none=True, default_scheme=None)
-    if parsed is None or parsed.scheme not in {"file", "s3"}:
-        return None
-
-    resolved = resolve_uri(first)
-    if resolved.scheme == "s3":
-        if not resolved.canonical.endswith(".zip"):
-            raise ValueError("S3 policy specs must be .zip bundles.")
-        return download_policy_spec_from_s3_as_zip(resolved.canonical), False
-
-    local_path = resolved.local_path
-    if local_path is None:
-        raise ValueError(f"Cannot resolve local path for URI: {policy}")
-    if not local_path.exists():
-        raise FileNotFoundError(f"Bundle path not found: {local_path}")
-    if local_path.is_dir():
-        return _zip_directory_bundle(local_path), True
-    if local_path.suffix == ".zip":
-        return local_path, False
-    raise ValueError("Checkpoint bundle must be a directory or .zip file.")
-
-
-def _zip_directory_bundle(bundle_dir: Path) -> Path:
-    zip_fd, zip_path = tempfile.mkstemp(suffix=".zip", prefix="cogames_bundle_")
-    os.close(zip_fd)
-
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
-        for file_path in bundle_dir.rglob("*"):
+def _zip_directory_to(src: Path, dest: Path) -> None:
+    with zipfile.ZipFile(dest, "w", zipfile.ZIP_DEFLATED) as zipf:
+        for file_path in src.rglob("*"):
             if file_path.is_file():
-                zipf.write(file_path, arcname=file_path.relative_to(bundle_dir))
-
-    return Path(zip_path)
-
-
-def validate_bundle_in_isolation(policy_zip: Path, console: Console, *, season: str, server: str) -> bool:
-    console.print("[dim]Testing policy bundle can run 10 steps...[/dim]")
+                zipf.write(file_path, arcname=file_path.relative_to(src))
 
-    temp_dir = None
-    try:
-        temp_dir = create_temp_validation_env()
-        bundle_name = policy_zip.name
-        shutil.copy2(policy_zip, temp_dir / bundle_name)
 
-        env = os.environ.copy()
-        env["UV_NO_CACHE"] = "1"
-
-        res = subprocess.run(
-            [
-                "uv",
-                "run",
-                "cogames",
-                "validate-policy",
-                "--season",
-                season,
-                "--server",
-                server,
-                "--policy",
-                f"file://./{bundle_name}",
-            ],
-            cwd=temp_dir,
-            capture_output=True,
-            text=True,
-            timeout=300,
-            env=env,
-        )
-        if res.returncode != 0:
-            console.print("[red]Validation failed[/red]")
-            console.print(f"\n[red]Error:[/red]\n{res.stderr}")
-            if res.stdout:
-                console.print(f"\n[dim]Output:[/dim]\n{res.stdout}")
-            return False
-
-        console.print("[green]Validation passed[/green]")
-        return True
-    except subprocess.TimeoutExpired:
-        console.print("[red]Validation timed out after 5 minutes[/red]")
-        return False
-    finally:
-        if temp_dir and temp_dir.exists():
-            shutil.rmtree(temp_dir)
-
-
-def get_latest_pypi_version(package: str) -> str:
-    """Get the latest published version of a package from PyPI."""
-    response = httpx.get(f"https://pypi.org/pypi/{package}/json")
-    response.raise_for_status()
-    return response.json()["info"]["version"]
-
-
-def get_pypi_requires_python(package: str) -> str:
-    """Get the requires_python constraint from PyPI."""
-    response = httpx.get(f"https://pypi.org/pypi/{package}/json")
-    response.raise_for_status()
-    return response.json()["info"]["requires_python"]
-
-
-def create_temp_validation_env() -> Path:
-    """Create a temporary directory with a minimal pyproject.toml.
-
-    The pyproject.toml depends on the latest published cogames and cogames-agents packages.
-    Python version is constrained to match mettagrid's published wheels.
-    """
-    temp_dir = Path(tempfile.mkdtemp(prefix="cogames_submit_"))
-
-    latest_cogames_version = get_latest_pypi_version("cogames")
-    latest_agents_version = get_latest_pypi_version("cogames-agents")
-    mettagrid_requires_python = get_pypi_requires_python("mettagrid")
-
-    pyproject_content = f"""[project]
-name = "cogames-submission-validator"
-version = "0.1.0"
-requires-python = "{mettagrid_requires_python}"
-dependencies = ["cogames=={latest_cogames_version}", "cogames-agents=={latest_agents_version}"]
-
-[build-system]
-requires = ["setuptools>=42"]
-build-backend = "setuptools.build_meta"
-"""
-
-    pyproject_path = temp_dir / "pyproject.toml"
-    pyproject_path.write_text(pyproject_content)
-
-    return temp_dir
-
-
-def copy_files_maintaining_structure(files: list[Path], dest_dir: Path) -> None:
-    """Copy files to destination, maintaining directory structure.
-
-    If a file is 'train_dir/model.pt', it will be copied to 'dest_dir/train_dir/model.pt'.
-    """
-    for file_path in files:
-        dest_path = dest_dir / file_path
-
-        if file_path.is_dir():
-            shutil.copytree(file_path, dest_path, dirs_exist_ok=True)
-        else:
-            dest_path.parent.mkdir(parents=True, exist_ok=True)
-            shutil.copy2(file_path, dest_path)
-
-
-def validate_policy_spec(policy_spec: PolicySpec, env_cfg: MettaGridConfig) -> None:
-    env_cfg = env_cfg.model_copy()
-    env_cfg.game.max_steps = 10
-    n = env_cfg.game.num_agents
-    n_submitted = min(2, n)
-    noop_spec = PolicySpec(class_path="mettagrid.policy.noop.NoopPolicy")
-    if n_submitted < n:
-        policy_specs = [policy_spec, noop_spec]
-        assignments = [0] * n_submitted + [1] * (n - n_submitted)
-    else:
-        policy_specs = [policy_spec]
-        assignments = [0] * n
-    run_single_episode(
-        policy_specs=policy_specs,
-        assignments=assignments,
-        env=env_cfg,
-        results_uri=None,
-        replay_uri=None,
-        seed=42,
-        max_action_time_ms=10000,
-        device="cpu",
-    )
-
-
-def validate_policy_in_isolation(
-    policy_spec: PolicySpec,
-    include_files: list[Path],
-    console: Console,
-    setup_script: str | None = None,
-    *,
-    season: str,
-    server: str,
-) -> bool:
-    def _format_policy_arg(spec: PolicySpec) -> str:
-        parts = [f"class={spec.class_path}"]
-        if spec.data_path:
-            parts.append(f"data={spec.data_path}")
-        for key, value in spec.init_kwargs.items():
-            parts.append(f"kw.{key}={value}")
-        return ",".join(parts)
-
-    console.print("[dim]Testing policy can run 10 steps...[/dim]")
-
-    temp_dir = None
-    try:
-        temp_dir = create_temp_validation_env()
-        copy_files_maintaining_structure(include_files, temp_dir)
-
-        policy_arg = _format_policy_arg(policy_spec)
-
-        def _run_from_tmp_dir(cmd: list[str]) -> subprocess.CompletedProcess[str]:
-            env = os.environ.copy()
-            env["UV_NO_CACHE"] = "1"
-            res = subprocess.run(
-                cmd,
-                cwd=temp_dir,
-                capture_output=True,
-                text=True,
-                timeout=300,
-                env=env,
-            )
-            if not res.returncode == 0:
-                console.print("[red]Validation failed[/red]")
-                console.print(f"\n[red]Error:[/red]\n{res.stderr}")
-                if res.stdout:
-                    console.print(f"\n[dim]Output:[/dim]\n{res.stdout}")
-                raise Exception("Validation failed")
-            return res
-
-        _run_from_tmp_dir(["uv", "run", "cogames", "version"])
-
-        validate_cmd = [
-            "uv",
-            "run",
-            "cogames",
-            "validate-policy",
-            "--policy",
-            policy_arg,
-            "--season",
-            season,
-            "--server",
-            server,
-        ]
-        if setup_script:
-            validate_cmd.extend(["--setup-script", setup_script])
-
-        _run_from_tmp_dir(validate_cmd)
-
-        console.print("[green]Validation passed[/green]")
-        return True
-
-    except subprocess.TimeoutExpired:
-        console.print("[red]Validation timed out after 5 minutes[/red]")
-        return False
-    except Exception:
-        return False
-    finally:
-        if temp_dir and temp_dir.exists():
-            shutil.rmtree(temp_dir)
+def _collect_ancestor_init_files(include_files: list[Path]) -> list[Path]:
+    found: set[Path] = set()
+    for path in include_files:
+        parent = path.parent
+        while parent != Path(".") and parent != parent.parent:
+            init = parent / "__init__.py"
+            if init.is_file():
+                found.add(init)
+            parent = parent.parent
+    return sorted(found)
 
 
 def create_submission_zip(
@@ -335,156 +100,169 @@ def create_submission_zip(
         setup_script=setup_script,
     )
 
+    all_files: dict[str, Path] = {}
+    for init_path in _collect_ancestor_init_files(include_files):
+        all_files[str(init_path)] = init_path
+    for file_path in include_files:
+        if file_path.is_dir():
+            for root, _, files in os.walk(file_path):
+                for file in files:
+                    full = Path(root) / file
+                    all_files[str(full)] = full
+        else:
+            all_files[str(file_path)] = file_path
+
     with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
         zipf.writestr(data=submission_spec.model_dump_json(), zinfo_or_arcname=POLICY_SPEC_FILENAME)
-
-        for file_path in include_files:
-            if file_path.is_dir():
-                for root, _, files in os.walk(file_path):
-                    for file in files:
-                        file_full_path = Path(root) / file
-                        zipf.write(file_full_path, arcname=file_full_path)
-            else:
-                zipf.write(file_path, arcname=file_path)
+        for arcname, path in all_files.items():
+            zipf.write(path, arcname=arcname)
 
     return Path(zip_path)
 
 
+def create_bundle(
+    ctx: typer.Context,
+    policy: str,
+    output: Path,
+    include_files: list[str] | None = None,
+    init_kwargs: dict[str, str] | None = None,
+    setup_script: str | None = None,
+) -> Path:
+    # TODO: Unify the two paths below. For URI inputs, extract the PolicySpec from the
+    # bundle so we can apply init_kwargs/include_files/setup_script, then re-zip.
+    local = localize_uri(policy) if parse_uri(policy, allow_none=True, default_scheme=None) else None
+    if local is not None:
+        if init_kwargs or include_files or setup_script:
+            console.print("[red]Error:[/red] Extra files/kwargs are not supported with bundle URIs.")
+            raise typer.Exit(1)
+        console.print(f"[dim]Packaging existing bundle: {local}[/dim]")
+        if local.is_dir():
+            _zip_directory_to(local, output)
+        else:
+            shutil.copy2(local, output)
+        console.print(f"[dim]Bundle size: {output.stat().st_size / 1024:.0f} KB[/dim]")
+        return output
+
+    policy_spec = get_policy_spec(ctx, policy)
+    console.print(f"[dim]Policy class: {policy_spec.class_path}[/dim]")
+
+    if init_kwargs:
+        merged_kwargs = {**policy_spec.init_kwargs, **init_kwargs}
+        policy_spec = PolicySpec(
+            class_path=policy_spec.class_path,
+            data_path=policy_spec.data_path,
+            init_kwargs=merged_kwargs,
+        )
+
+    if policy_spec.init_kwargs:
+        console.print(f"[dim]Init kwargs: {policy_spec.init_kwargs}[/dim]")
+
+    cwd = Path.cwd().resolve()
+    if policy_spec.data_path:
+        data_rel = str(_resolve_path_within_cwd(policy_spec.data_path, cwd))
+        policy_spec = PolicySpec(
+            class_path=policy_spec.class_path,
+            data_path=data_rel,
+            init_kwargs=policy_spec.init_kwargs,
+        )
+        console.print(f"[dim]Data path: {data_rel}[/dim]")
+
+    setup_script_rel: str | None = None
+    if setup_script:
+        setup_script_rel = str(_resolve_path_within_cwd(setup_script, cwd))
+        console.print(f"[dim]Setup script: {setup_script_rel}[/dim]")
+
+    files_to_include = []
+    if policy_spec.data_path:
+        files_to_include.append(policy_spec.data_path)
+    if setup_script_rel:
+        files_to_include.append(setup_script_rel)
+    if include_files:
+        files_to_include.extend(include_files)
+
+    validated_paths: list[Path] = []
+    if files_to_include:
+        validated_paths = validate_paths(files_to_include)
+        console.print(f"[dim]Including {len(validated_paths)} file(s)[/dim]")
+
+    tmp_zip = create_submission_zip(validated_paths, policy_spec, setup_script=setup_script_rel)
+    shutil.move(str(tmp_zip), str(output))
+    console.print(f"[dim]Bundle size: {output.stat().st_size / 1024:.0f} KB[/dim]")
+    return output
+
+
+def validate_bundle(policy_uri: str, env_cfg: MettaGridConfig) -> None:
+    """Validate a policy bundle by running a short episode in process isolation."""
+    env_cfg.game.max_steps = 10
+
+    spec = EpisodeSpec(
+        policy_uris=[policy_uri],
+        assignments=[0] * env_cfg.game.num_agents,
+        env=env_cfg,
+        seed=42,
+        max_action_time_ms=10000,
+    )
+
+    with tempfile.NamedTemporaryFile(suffix=".json", delete=True) as results_file:
+        res = run_episode_isolated(spec, Path(results_file.name))
+        console.print(f"[dim]Ran for {res.steps} steps[/dim]")
+
+        non_noop_actions = sum(
+            v for k, v in res.stats["agent"][0].items() if k.startswith("action.") and ".noop." not in k
+        )
+        if non_noop_actions == 0:
+            console.print("[yellow]Warning: Policy took no actions (all no-ops)[/yellow]")
+            raise typer.Exit(1)
+
+
 def upload_submission(
     client: TournamentServerClient,
     zip_path: Path,
     submission_name: str,
-    console: Console,
     season: str | None = None,
 ) -> UploadResult | None:
     """Upload submission to CoGames backend using a presigned S3 URL."""
     console.print("[bold]Uploading[/bold]")
 
-    try:
-        presigned_data = client.get_presigned_upload_url()
-        upload_url = presigned_data.get("upload_url")
-        upload_id = presigned_data.get("upload_id")
+    presigned_data = client.get_presigned_upload_url()
+    upload_url = presigned_data.get("upload_url")
+    upload_id = presigned_data.get("upload_id")
 
-        if not upload_url or not upload_id:
-            console.print("[red]Upload URL missing from response[/red]")
-            return None
-    except httpx.TimeoutException:
-        console.print("[red]Timed out while requesting upload URL[/red]")
-        return None
-    except httpx.HTTPStatusError as exc:
-        console.print(f"[red]Failed to get upload URL ({exc.response.status_code})[/red]")
-        console.print(f"[dim]{exc.response.text}[/dim]")
-        return None
-    except Exception as e:
-        console.print(f"[red]Error requesting upload URL: {e}[/red]")
-        return None
+    if not upload_url or not upload_id:
+        raise ValueError("Upload URL missing from response")
 
     console.print("[dim]Uploading to storage...[/dim]")
 
-    try:
-        with open(zip_path, "rb") as f:
-            upload_response = httpx.put(
-                upload_url,
-                content=f,
-                headers={"Content-Type": "application/zip"},
-                timeout=600.0,
-            )
-        upload_response.raise_for_status()
-    except httpx.TimeoutException:
-        console.print("[red]Upload timed out after 10 minutes[/red]")
-        return None
-    except httpx.HTTPStatusError as exc:
-        console.print(f"[red]Upload failed with status {exc.response.status_code}[/red]")
-        console.print(f"[dim]{exc.response.text}[/dim]")
-        return None
-    except Exception as e:
-        console.print(f"[red]Upload error: {e}[/red]")
-        return None
+    with open(zip_path, "rb") as f:
+        upload_response = httpx.put(
+            upload_url,
+            content=f,
+            headers={"Content-Type": "application/zip"},
+            timeout=600.0,
+        )
+    upload_response.raise_for_status()
 
     if not season:
         console.print("[dim]Uploading policy...[/dim]")
     else:
         console.print(f"[dim]Uploading policy and submitting to season {season}...[/dim]")
 
+    result = client.complete_policy_upload(upload_id, submission_name, season=season)
+    submission_id = result.get("id")
+    name = result.get("name")
+    version = result.get("version")
+    pools = result.get("pools")
+    if submission_id is None or name is None or version is None:
+        raise ValueError("Missing fields in response")
     try:
-        result = client.complete_policy_upload(upload_id, submission_name, season=season)
-        submission_id = result.get("id")
-        name = result.get("name")
-        version = result.get("version")
-        pools = result.get("pools")
-        if submission_id is not None and name is not None and version is not None:
-            try:
-                return UploadResult(
-                    policy_version_id=uuid.UUID(str(submission_id)),
-                    name=name,
-                    version=version,
-                    pools=pools,
-                )
-            except ValueError:
-                console.print(f"[red]Invalid submission ID returned: {submission_id}[/red]")
-                return None
-
-        console.print("[red]Missing fields in response[/red]")
-        return None
-    except httpx.TimeoutException:
-        console.print("[red]Registration timed out[/red]")
-        return None
-    except httpx.HTTPStatusError as exc:
-        console.print(f"[red]Registration failed with status {exc.response.status_code}[/red]")
-        console.print(f"[dim]{exc.response.text}[/dim]")
-        return None
-    except Exception as e:
-        console.print(f"[red]Registration error: {e}[/red]")
-        return None
-
-
-def _upload_policy_bundle(
-    bundle_result: tuple[Path, bool],
-    *,
-    client: TournamentServerClient,
-    name: str,
-    console: Console,
-    init_kwargs: dict[str, str] | None,
-    include_files: list[str] | None,
-    setup_script: str | None,
-    skip_validation: bool,
-    dry_run: bool,
-    validation_season: str,
-    server: str,
-    season: str | None = None,
-) -> UploadResult | None:
-    bundle_zip, cleanup_bundle_zip = bundle_result
-
-    try:
-        if init_kwargs or include_files or setup_script:
-            console.print("[red]Error:[/red] Extra files/kwargs are not supported when uploading a bundle URI.")
-            console.print(
-                "Upload the bundle as-is, or use a short policy name or URI with local files to "
-                "build a new submission zip."
-            )
-            return None
-
-        if not skip_validation:
-            if not validate_bundle_in_isolation(bundle_zip, console, season=validation_season, server=server):
-                console.print("\n[red]Upload aborted due to validation failure.[/red]")
-                return None
-        else:
-            console.print("[dim]Skipping validation[/dim]")
-
-        if dry_run:
-            console.print("[green]Dry run complete[/green]")
-            return None
-
-        with client:
-            result = upload_submission(client, bundle_zip, name, console, season=season)
-        if not result:
-            console.print("\n[red]Upload failed.[/red]")
-            return None
-
-        return result
-    finally:
-        if cleanup_bundle_zip and bundle_zip.exists():
-            bundle_zip.unlink()
+        return UploadResult(
+            policy_version_id=uuid.UUID(str(submission_id)),
+            name=name,
+            version=version,
+            pools=pools,
+        )
+    except ValueError as exc:
+        raise ValueError(f"Invalid submission ID returned: {submission_id}") from exc
 
 
 def upload_policy(
@@ -498,11 +276,8 @@ def upload_policy(
     dry_run: bool = False,
     skip_validation: bool = False,
     setup_script: str | None = None,
-    validation_season: str = "",
     season: str | None = None,
 ) -> UploadResult | None:
-    from cogames.cli.client import TournamentServerClient
-
     if dry_run:
         console.print("[dim]Dry run mode - no upload[/dim]\n")
 
@@ -510,116 +285,47 @@ def upload_policy(
     if not client:
         return None
 
-    try:
-        bundle_result = _maybe_resolve_checkpoint_bundle_uri(policy)
-    except Exception as e:
-        console.print(f"[red]Error resolving checkpoint bundle:[/red] {e}")
-        return None
+    with tempfile.TemporaryDirectory(prefix="cogames_bundle_") as tmp_dir:
+        zip_path = Path(tmp_dir) / "bundle.zip"
 
-    if bundle_result is not None:
-        return _upload_policy_bundle(
-            bundle_result,
-            client=client,
-            name=name,
-            console=console,
-            init_kwargs=init_kwargs,
+        create_bundle(
+            ctx=ctx,
+            policy=policy,
+            output=zip_path,
             include_files=include_files,
+            init_kwargs=init_kwargs,
             setup_script=setup_script,
-            skip_validation=skip_validation,
-            dry_run=dry_run,
-            validation_season=validation_season,
-            server=server,
-            season=season,
         )
 
-    try:
-        policy_spec = get_policy_spec(ctx, policy)
-    except Exception as e:
-        console.print(f"[red]Error parsing policy:[/red] {e}")
-        return None
-
-    if init_kwargs:
-        merged_kwargs = {**policy_spec.init_kwargs, **init_kwargs}
-        policy_spec = PolicySpec(
-            class_path=policy_spec.class_path,
-            data_path=policy_spec.data_path,
-            init_kwargs=merged_kwargs,
-        )
-
-    cwd = Path.cwd().resolve()
-    if policy_spec.data_path:
-        try:
-            resolved = Path(policy_spec.data_path).expanduser().resolve()
-            data_rel = str(resolved.relative_to(cwd))
-        except ValueError:
-            console.print("[red]Error:[/red] Policy weights path must be within the current directory.")
-            console.print(f"[dim]{policy_spec.data_path}[/dim]")
-            return None
-        policy_spec = PolicySpec(
-            class_path=policy_spec.class_path,
-            data_path=data_rel,
-            init_kwargs=policy_spec.init_kwargs,
-        )
-
-    setup_script_rel: str | None = None
-    if setup_script:
-        try:
-            resolved = Path(setup_script).expanduser().resolve()
-            setup_script_rel = str(resolved.relative_to(cwd))
-        except ValueError:
-            console.print("[red]Error:[/red] Setup script path must be within the current directory.")
-            console.print(f"[dim]{setup_script}[/dim]")
-            return None
-
-    files_to_include = []
-    if policy_spec.data_path:
-        files_to_include.append(policy_spec.data_path)
-    if setup_script_rel:
-        files_to_include.append(setup_script_rel)
-    if include_files:
-        files_to_include.extend(include_files)
-
-    validated_paths: list[Path] = []
-    if files_to_include:
-        try:
-            validated_paths = validate_paths(files_to_include, console)
-        except (ValueError, FileNotFoundError):
-            return None
+        if not skip_validation:
+            cmd = [
+                sys.executable,
+                "-m",
+                "cogames",
+                "validate-bundle",
+                "--policy",
+                zip_path.as_uri(),
+                "--server",
+                server,
+            ]
+            if season:
+                cmd.extend(["--season", season])
+            result = subprocess.run(cmd, text=True, timeout=300)
+            if result.returncode != 0:
+                console.print("[red]Validation failed[/red]")
+                return None
+            console.print("[green]Validation passed[/green]")
+        else:
+            console.print("[dim]Skipping validation[/dim]")
 
-    if not skip_validation:
-        if not validate_policy_in_isolation(
-            policy_spec,
-            validated_paths,
-            console,
-            setup_script=setup_script_rel,
-            season=validation_season,
-            server=server,
-        ):
-            console.print("\n[red]Upload aborted due to validation failure.[/red]")
+        if dry_run:
+            console.print("[green]Dry run complete[/green]")
             return None
-    else:
-        console.print("[dim]Skipping validation[/dim]")
 
-    try:
-        zip_path = create_submission_zip(validated_paths, policy_spec, setup_script=setup_script_rel)
-    except Exception as e:
-        console.print(f"[red]Error creating zip:[/red] {e}")
-        return None
-
-    if dry_run:
-        console.print("[green]Dry run complete[/green]")
-        if zip_path.exists():
-            zip_path.unlink()
-        return None
-
-    try:
         with client:
-            result = upload_submission(client, zip_path, name, console, season=season)
+            result = upload_submission(client, zip_path, name, season=season)
         if not result:
             console.print("\n[red]Upload failed.[/red]")
             return None
 
         return result
-    finally:
-        if zip_path.exists():
-            zip_path.unlink()