plato-sdk-v2 2.3.11__py3-none-any.whl → 2.4.0__py3-none-any.whl

plato/v1/cli/chronos.py

@@ -2,14 +2,21 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
+import logging
+import os
+import subprocess
+import tempfile
 from pathlib import Path
+from typing import Annotated
 
 import typer
 
 from plato.v1.cli.utils import console
 
 chronos_app = typer.Typer(help="Chronos job management commands.")
+logger = logging.getLogger(__name__)
 
 
 @chronos_app.command()
@@ -178,14 +185,14 @@ def example(
                 "max_attempts": 3,
                 "use_backtrack": True,
                 "skill_runner": {
-                    "image": "claude-code:2.1.6",
+                    "image": "claude-code:2.1.5",
                     "config": {"model_name": "anthropic/claude-sonnet-4-20250514", "max_turns": 100},
                 },
             },
             "agent_configs": {
                 "skill_runner": {
                     "agent": "claude-code",
-                    "version": "2.1.6",
+                    "version": "2.1.5",
                     "config": {"model_name": "anthropic/claude-sonnet-4-20250514", "max_turns": 100},
                 }
             },
@@ -217,3 +224,527 @@ def example(
         console.print(f"[green]✅ Example config written to {output}[/green]")
     else:
         console.print(json_output)
+
+
+def _get_world_runner_dockerfile() -> Path:
+    """Get the path to the world runner Dockerfile template."""
+    return Path(__file__).parent / "templates" / "world-runner.Dockerfile"
+
+
+def _build_world_runner_image(platform_override: str | None = None) -> str:
+    """Build the world runner Docker image if needed."""
+    image_tag = "plato-world-runner:latest"
+    dockerfile_path = _get_world_runner_dockerfile()
+
+    if not dockerfile_path.exists():
+        raise FileNotFoundError(f"World runner Dockerfile not found: {dockerfile_path}")
+
+    docker_platform = _get_docker_platform(platform_override)
+
+    # Check if image exists
+    result = subprocess.run(
+        ["docker", "images", "-q", image_tag],
+        capture_output=True,
+        text=True,
+    )
+
+    if result.stdout.strip():
+        # Image exists
+        return image_tag
+
+    console.print("[blue]Building world runner image...[/blue]")
+
+    cmd = [
+        "docker",
+        "build",
+        "--platform",
+        docker_platform,
+        "-t",
+        image_tag,
+        "-f",
+        str(dockerfile_path),
+        str(dockerfile_path.parent),
+    ]
+
+    result = subprocess.run(cmd)
+    if result.returncode != 0:
+        raise RuntimeError("Failed to build world runner image")
+
+    console.print(f"[green]✅ Built {image_tag}[/green]")
+    return image_tag
+
+
+def _get_docker_platform(override: str | None = None) -> str:
+    """Get the appropriate Docker platform for the current system."""
+    if override:
+        return override
+
+    import platform as plat
+
+    system = plat.system()
+    machine = plat.machine().lower()
+
+    if system == "Darwin" and machine in ("arm64", "aarch64"):
+        return "linux/arm64"
+    elif system == "Linux" and machine in ("arm64", "aarch64"):
+        return "linux/arm64"
+    else:
+        return "linux/amd64"
+
+
+def _get_docker_host_ip() -> str:
+    """Get the Docker host IP address accessible from containers."""
+    try:
+        result = subprocess.run(
+            ["docker", "network", "inspect", "bridge", "--format", "{{range .IPAM.Config}}{{.Gateway}}{{end}}"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip()
+    except Exception:
+        pass
+    # Fallback to common Docker gateway IP
+    return "172.17.0.1"
+
+
+def _build_agent_image(
+    agent_name: str,
+    agents_dir: Path,
+    platform_override: str | None = None,
+) -> bool:
+    """Build a local agent Docker image."""
+    agents_dir = agents_dir.expanduser().resolve()
+    agent_path = agents_dir / agent_name
+    dockerfile_path = agent_path / "Dockerfile"
+
+    if not dockerfile_path.exists():
+        logger.warning(f"No Dockerfile found for agent '{agent_name}' at {dockerfile_path}")
+        return False
+
+    image_tag = f"{agent_name}:latest"
+    docker_platform = _get_docker_platform(platform_override)
+
+    # Determine build context - check if we're in plato-client structure
+    plato_client_root = agents_dir.parent if agents_dir.name == "agents" else None
+
+    if plato_client_root and (plato_client_root / "python-sdk").exists():
+        build_context = str(plato_client_root)
+        target = "dev"
+        console.print(f"[blue]Building {image_tag} (dev mode from {build_context})...[/blue]")
+    else:
+        build_context = str(agent_path)
+        target = "prod"
+        console.print(f"[blue]Building {image_tag} (prod mode from {build_context})...[/blue]")
+
+    console.print(f"[dim]Platform: {docker_platform}[/dim]")
+
+    cmd = [
+        "docker",
+        "build",
+        "--platform",
+        docker_platform,
+        "--build-arg",
+        f"PLATFORM={docker_platform}",
+        "--target",
+        target,
+        "-t",
+        image_tag,
+        "-f",
+        str(dockerfile_path),
+        build_context,
+    ]
+
+    result = subprocess.run(cmd)
+    if result.returncode != 0:
+        console.print(f"[red]❌ Failed to build {image_tag}[/red]")
+        return False
+
+    console.print(f"[green]✅ Built {image_tag}[/green]")
+    return True
+
+
+def _extract_agent_images_from_config(config_data: dict) -> list[str]:
+    """Extract local agent image names from config data."""
+    images = []
+
+    # Check agents section
+    agents = config_data.get("agents", {})
+    for agent_config in agents.values():
+        if isinstance(agent_config, dict):
+            image = agent_config.get("image", "")
+            # Only include local images (no registry prefix)
+            if image and "/" not in image.split(":")[0]:
+                name = image.split(":")[0]
+                if name not in images:
+                    images.append(name)
+
+    # Also check direct coder/verifier fields
+    for field in ["coder", "verifier", "skill_runner"]:
+        agent_config = config_data.get(field, {})
+        if isinstance(agent_config, dict):
+            image = agent_config.get("image", "")
+            if image and "/" not in image.split(":")[0]:
+                name = image.split(":")[0]
+                if name not in images:
+                    images.append(name)
+
+    return images
+
+
+async def _create_chronos_session(
+    chronos_url: str,
+    api_key: str,
+    world_name: str,
+    world_config: dict,
+    plato_session_id: str | None = None,
+) -> dict:
+    """Create a session in Chronos."""
+    import httpx
+
+    url = f"{chronos_url.rstrip('/')}/api/sessions"
+
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(
+            url,
+            json={
+                "world_name": world_name,
+                "world_config": world_config,
+                "plato_session_id": plato_session_id,
+            },
+            headers={"x-api-key": api_key},
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+async def _close_chronos_session(
+    chronos_url: str,
+    api_key: str,
+    session_id: str,
+) -> None:
+    """Close a Chronos session."""
+    import httpx
+
+    url = f"{chronos_url.rstrip('/')}/api/sessions/{session_id}/close"
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(url, headers={"x-api-key": api_key})
+            response.raise_for_status()
+            logger.info(f"Closed Chronos session: {session_id}")
+    except Exception as e:
+        logger.warning(f"Failed to close Chronos session: {e}")
+
+
+async def _run_dev_impl(
+    world_dir: Path,
+    config_path: Path,
+    agents_dir: Path | None = None,
+    platform_override: str | None = None,
+    env_timeout: int = 7200,
+) -> None:
+    """Run a world locally in a Docker container.
+
+    This:
+    1. Builds local agent images if --agents-dir is provided
+    2. Creates Plato environments
+    3. Creates Chronos session for OTel traces
+    4. Runs the world in a Docker container with docker.sock mounted
+    """
+    from plato._generated.models import Envs
+    from plato.v2 import AsyncPlato
+    from plato.worlds.config import EnvConfig
+
+    # Get required env vars
+    chronos_url = os.environ.get("CHRONOS_URL", "https://chronos.plato.so")
+    api_key = os.environ.get("PLATO_API_KEY")
+
+    if not api_key:
+        raise ValueError("PLATO_API_KEY environment variable is required")
+
+    # Resolve paths
+    world_dir = world_dir.expanduser().resolve()
+    config_path = config_path.expanduser().resolve()
+
+    # Load config
+    with open(config_path) as f:
+        raw_config = json.load(f)
+
+    # Handle Chronos-style config format
+    if "world_config" in raw_config:
+        config_data = raw_config["world_config"].copy()
+        top_level_secrets = raw_config.get("secrets", {})
+        if top_level_secrets:
+            config_data.setdefault("secrets", {})
+            config_data["secrets"].update(top_level_secrets)
+    else:
+        config_data = raw_config.copy()
+
+    # Determine world name from config
+    world_package = raw_config.get("world_package", "")
+    if world_package.startswith("plato-world-"):
+        world_name = world_package[len("plato-world-") :]
+    else:
+        world_name = world_package or "unknown"
+
+    # Build local agent images if agents_dir is provided
+    if agents_dir:
+        agents_dir = agents_dir.expanduser().resolve()
+        agent_images = _extract_agent_images_from_config(config_data)
+        if agent_images:
+            console.print(f"[blue]Building agent images: {agent_images}[/blue]")
+            for agent_name in agent_images:
+                success = _build_agent_image(agent_name, agents_dir, platform_override)
+                if not success:
+                    raise RuntimeError(f"Failed to build agent image: {agent_name}")
+
+    # Import world module to get config class for environment detection
+    # We need to dynamically load the world from world_dir
+    import sys
+
+    sys.path.insert(0, str(world_dir / "src"))
+
+    try:
+        # Try to import the world module
+
+        world_module_path = list((world_dir / "src").glob("*_world/*.py"))
+        if not world_module_path:
+            world_module_path = list((world_dir / "src").glob("*/__init__.py"))
+
+        env_configs: list[EnvConfig] = []
+
+        # Try to extract env configs from world config
+        if "envs" in config_data:
+            for env_cfg in config_data["envs"]:
+                env_configs.append(Envs.model_validate(env_cfg).root)
+    finally:
+        if str(world_dir / "src") in sys.path:
+            sys.path.remove(str(world_dir / "src"))
+
+    # Create Plato client and session
+    plato = AsyncPlato()
+    session = None
+    plato_session_id: str | None = None
+    chronos_session_id: str | None = None
+
+    try:
+        if env_configs:
+            console.print(f"[blue]Creating {len(env_configs)} Plato environments...[/blue]")
+            session = await plato.sessions.create(envs=env_configs, timeout=env_timeout)
+            plato_session_id = session.session_id
+            console.print(f"[green]✅ Created Plato session: {plato_session_id}[/green]")
+
+            # Add session to config
+            config_data["plato_session"] = session.dump()
+
+        # Create Chronos session
+        console.print("[blue]Creating Chronos session...[/blue]")
+        chronos_session = await _create_chronos_session(
+            chronos_url=chronos_url,
+            api_key=api_key,
+            world_name=world_name,
+            world_config=config_data,
+            plato_session_id=plato_session_id,
+        )
+        chronos_session_id = chronos_session["public_id"]
+        console.print(f"[green]✅ Created Chronos session: {chronos_session_id}[/green]")
+        console.print(f"[dim]View at: {chronos_url}/sessions/{chronos_session_id}[/dim]")
+
+        # Add session info to config
+        config_data["session_id"] = chronos_session_id
+        # Use otel_url from backend response (uses tunnel if available), or construct it
+        otel_url = chronos_session.get("otel_url") or f"{chronos_url.rstrip('/')}/api/otel"
+        # For Docker containers, replace localhost with Docker gateway IP
+        if "localhost" in otel_url or "127.0.0.1" in otel_url:
+            docker_host_ip = _get_docker_host_ip()
+            otel_url = otel_url.replace("localhost", docker_host_ip).replace("127.0.0.1", docker_host_ip)
+        config_data["otel_url"] = otel_url
+        config_data["upload_url"] = chronos_session.get("upload_url", "")
+
+        # Write updated config to temp file
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            # Write in direct format (not Chronos format) for the world runner
+            json.dump(config_data, f)
+            container_config_path = f.name
+
+        # Create shared workspace volume for DIND compatibility
+        import uuid as uuid_mod
+
+        workspace_volume = f"plato-workspace-{uuid_mod.uuid4().hex[:8]}"
+        subprocess.run(
+            ["docker", "volume", "create", workspace_volume],
+            capture_output=True,
+        )
+        console.print(f"[blue]Created workspace volume: {workspace_volume}[/blue]")
+
+        try:
+            # Run world in Docker container
+            console.print("[blue]Starting world in Docker container...[/blue]")
+
+            docker_platform = _get_docker_platform(platform_override)
+
+            # Build world runner image if needed
+            world_runner_image = _build_world_runner_image(platform_override)
+
+            # Find python-sdk relative to world_dir (assumes plato-client structure)
+            # world_dir: plato-client/worlds/structured-execution
+            # python_sdk: plato-client/python-sdk
+            python_sdk_dir = world_dir.parent.parent / "python-sdk"
+
+            # For Docker containers, replace localhost with Docker gateway IP
+            docker_chronos_url = chronos_url
+            if "localhost" in docker_chronos_url or "127.0.0.1" in docker_chronos_url:
+                docker_host_ip = _get_docker_host_ip()
+                docker_chronos_url = docker_chronos_url.replace("localhost", docker_host_ip).replace(
+                    "127.0.0.1", docker_host_ip
+                )
+
+            docker_cmd = [
+                "docker",
+                "run",
+                "--rm",
+                "--platform",
+                docker_platform,
+                "--privileged",
+                "-v",
+                "/var/run/docker.sock:/var/run/docker.sock",
+                "-v",
+                f"{world_dir}:/world:ro",
+                "-v",
+                f"{python_sdk_dir}:/python-sdk:ro",  # Mount local SDK for dev
+                "-v",
+                f"{container_config_path}:/config.json:ro",
+                "-v",
+                f"{workspace_volume}:/tmp/workspace",  # Shared workspace volume
+                "-e",
+                f"WORLD_NAME={world_name}",
+                "-e",
+                f"WORKSPACE_VOLUME={workspace_volume}",  # Pass volume name for run_agent
+                "-e",
+                f"CHRONOS_URL={docker_chronos_url}",
+                "-e",
+                f"PLATO_API_KEY={api_key}",
+                "-e",
+                f"SESSION_ID={chronos_session_id}",
+                "-e",
+                f"OTEL_EXPORTER_OTLP_ENDPOINT={otel_url}",
+                "-e",
+                f"UPLOAD_URL={chronos_session.get('upload_url', '')}",
+            ]
+
+            # Add secrets as env vars
+            for key, value in config_data.get("secrets", {}).items():
+                docker_cmd.extend(["-e", f"{key.upper()}={value}"])
+
+            # Use world runner image
+            docker_cmd.append(world_runner_image)
+
+            console.print(f"[dim]Running: docker run ... {world_runner_image}[/dim]")
+
+            # Run and stream output
+            process = subprocess.Popen(
+                docker_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+            )
+
+            if process.stdout:
+                for line in process.stdout:
+                    print(line, end="")
+
+            process.wait()
+
+            if process.returncode != 0:
+                raise RuntimeError(f"World execution failed with exit code {process.returncode}")
+
+        finally:
+            os.unlink(container_config_path)
+            # Clean up workspace volume
+            subprocess.run(
+                ["docker", "volume", "rm", "-f", workspace_volume],
+                capture_output=True,
+            )
+            console.print(f"[dim]Cleaned up workspace volume: {workspace_volume}[/dim]")
+
+    finally:
+        if session:
+            console.print("[blue]Closing Plato session...[/blue]")
+            await session.close()
+        await plato.close()
+
+        if chronos_session_id:
+            await _close_chronos_session(chronos_url, api_key, chronos_session_id)
+
+
+@chronos_app.command()
+def dev(
+    config: Annotated[
+        Path,
+        typer.Argument(help="Path to config JSON file", exists=True, readable=True),
+    ],
+    world_dir: Annotated[
+        Path,
+        typer.Option("--world-dir", "-w", help="Directory containing world source code"),
+    ],
+    agents_dir: Annotated[
+        Path | None,
+        typer.Option("--agents-dir", "-a", help="Directory containing agent source code"),
+    ] = None,
+    platform: Annotated[
+        str | None,
+        typer.Option("--platform", "-p", help="Docker platform (e.g., linux/amd64)"),
+    ] = None,
+    env_timeout: Annotated[
+        int,
+        typer.Option("--env-timeout", help="Timeout for environment creation (seconds)"),
+    ] = 7200,
+):
+    """
+    Run a world locally for development/debugging.
+
+    This runs the world in a Docker container with docker.sock mounted,
+    allowing the world to spawn agent containers.
+
+    \b
+    Config format (same as Chronos launch):
+    {
+        "world_package": "plato-world-structured-execution",
+        "world_config": {
+            "sim_name": "my-task",
+            "steps": [...],
+            "agents": {
+                "skill_runner": {
+                    "image": "computer-use:latest",
+                    "config": {"model_name": "..."}
+                }
+            }
+        },
+        "secrets": {
+            "gemini_api_key": "...",
+            "plato_api_key": "..."
+        }
+    }
+
+    Examples:
+        plato chronos dev config.json --world-dir ~/worlds/my-world
+        plato chronos dev config.json -w ~/worlds/my-world -a ~/agents
+        plato chronos dev config.json -w ~/worlds/my-world --platform linux/amd64
+    """
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    if not os.environ.get("PLATO_API_KEY"):
+        console.print("[red]❌ PLATO_API_KEY environment variable required[/red]")
+        raise typer.Exit(1)
+
+    try:
+        asyncio.run(_run_dev_impl(world_dir, config, agents_dir, platform, env_timeout))
+    except Exception as e:
+        console.print(f"[red]❌ Failed: {e}[/red]")
+        logger.exception("World execution failed")
+        raise typer.Exit(1)

plato/v1/cli/sandbox.py

@@ -1644,6 +1644,8 @@ def sandbox_state_cmd(
                 return True, False, None
         return False, False, None
 
+    all_mutations = []
+
     if session_id:
         if not json_output:
             console.print(f"[cyan]Getting state for session: {session_id}[/cyan]")
@@ -1651,6 +1653,7 @@ def sandbox_state_cmd(
             response = sessions_state.sync(
                 client=client,
                 session_id=session_id,
+                merge_mutations=True,
                 x_api_key=api_key,
             )
             if response and response.results:
@@ -1664,6 +1667,13 @@ def sandbox_state_cmd(
                     has_error = has_error or e
                     if msg:
                         error_message = msg
+                    # Extract mutations from state
+                    if isinstance(result, dict) and "state" in result:
+                        state_data = result.get("state", {})
+                        if isinstance(state_data, dict):
+                            mutations = state_data.get("mutations", [])
+                            if mutations:
+                                all_mutations.extend(mutations)
     elif job_id:
         if not json_output:
             console.print(f"[cyan]Getting state for job: {job_id}[/cyan]")
@@ -1679,6 +1689,13 @@ def sandbox_state_cmd(
                 has_mutations = m
                 has_error = e
                 error_message = msg
+                # Extract mutations from state
+                if isinstance(state_dict, dict) and "state" in state_dict:
+                    state_data = state_dict.get("state", {})
+                    if isinstance(state_data, dict):
+                        mutations = state_data.get("mutations", [])
+                        if mutations:
+                            all_mutations.extend(mutations)
     elif job_group_id:
         if not json_output:
             console.print(f"[cyan]Getting state for job_group: {job_group_id}[/cyan]")
@@ -1686,6 +1703,7 @@ def sandbox_state_cmd(
             response = sessions_state.sync(
                 client=client,
                 session_id=job_group_id,
+                merge_mutations=True,
                 x_api_key=api_key,
             )
             if response and response.results:
@@ -1699,6 +1717,13 @@ def sandbox_state_cmd(
                     has_error = has_error or e
                     if msg:
                         error_message = msg
+                    # Extract mutations from state
+                    if isinstance(result, dict) and "state" in result:
+                        state_data = result.get("state", {})
+                        if isinstance(state_data, dict):
+                            mutations = state_data.get("mutations", [])
+                            if mutations:
+                                all_mutations.extend(mutations)
     else:
         console.print("[red]❌ .sandbox.yaml missing session_id, job_id, or job_group_id[/red]")
         raise typer.Exit(1)
@@ -1719,6 +1744,26 @@ def sandbox_state_cmd(
         elif state_dict:
             console.print("\n[bold]Environment State:[/bold]")
             console.print(json.dumps(state_dict, indent=2, default=str))
+
+            # Display mutations if any
+            if all_mutations:
+                console.print(f"\n[bold red]Mutations ({len(all_mutations)}):[/bold red]")
+                # Group by table and action for summary
+                from collections import defaultdict
+
+                table_ops: dict[str, dict[str, int]] = defaultdict(lambda: {"INSERT": 0, "UPDATE": 0, "DELETE": 0})
+                for mutation in all_mutations:
+                    table = mutation.get("table_name", mutation.get("table", "unknown"))
+                    op = mutation.get("action", mutation.get("operation", "UNKNOWN")).upper()
+                    if op in table_ops[table]:
+                        table_ops[table][op] += 1
+
+                console.print("\n  [dim]Table                           INSERT  UPDATE  DELETE[/dim]")
+                console.print("  [dim]───────────────────────────────────────────────────────[/dim]")
+                for table, ops in sorted(table_ops.items(), key=lambda x: sum(x[1].values()), reverse=True):
+                    console.print(f"  {table:<30} {ops['INSERT']:>6}  {ops['UPDATE']:>6}  {ops['DELETE']:>6}")
+            else:
+                console.print("\n[green]No mutations recorded[/green]")
         else:
             console.print("[yellow]No state returned[/yellow]")
 
@@ -1835,7 +1880,8 @@ def sandbox_clear_audit(
             sql_cmd = f"CONTAINER=$(docker ps --format '{{{{.Names}}}}\\t{{{{.Image}}}}' | grep -i postgres | head -1 | cut -f1) && docker exec $CONTAINER psql -U {db_user} -d {db_database} -c \"{truncate_sql}\""
         elif db_type in ("mysql", "mariadb"):
             # Find the mysql/mariadb container and exec into it
-            sql_cmd = f"CONTAINER=$(docker ps --format '{{{{.Names}}}}\\t{{{{.Image}}}}' | grep -iE 'mysql|mariadb' | head -1 | cut -f1) && docker exec $CONTAINER mysql -u {db_user} -p'{db_password}' {db_database} -e 'SET FOREIGN_KEY_CHECKS=0; DELETE FROM audit_log; SET FOREIGN_KEY_CHECKS=1;'"
+            # Use mariadb client (mysql is a symlink or may not exist in newer mariadb images)
+            sql_cmd = f"CONTAINER=$(docker ps --format '{{{{.Names}}}}\\t{{{{.Image}}}}' | grep -iE 'mysql|mariadb' | head -1 | cut -f1) && docker exec $CONTAINER mariadb -u {db_user} -p'{db_password}' {db_database} -e 'SET FOREIGN_KEY_CHECKS=0; DELETE FROM audit_log; SET FOREIGN_KEY_CHECKS=1;'"
         else:
             if not json_output:
                 console.print(f"[yellow]⚠ Unsupported db_type '{db_type}' for listener '{name}'[/yellow]")

plato/v1/cli/templates/world-runner.Dockerfile

@@ -0,0 +1,27 @@
+# World runner image for plato chronos dev
+# Includes git, docker CLI, and Python dependencies
+
+FROM python:3.12-slim
+
+# Install git and docker CLI
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    curl \
+    ca-certificates \
+    && curl -fsSL https://get.docker.com -o get-docker.sh \
+    && sh get-docker.sh \
+    && rm get-docker.sh \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install uv for fast package installation
+RUN pip install --no-cache-dir uv
+
+WORKDIR /world
+
+# Entry point expects:
+# - /world mounted with world source
+# - /python-sdk mounted with plato SDK source (optional, for dev)
+# - /config.json mounted with config
+# - WORLD_NAME env var set
+CMD ["bash", "-c", "if [ -d /python-sdk ]; then uv pip install --system /python-sdk; fi && uv pip install --system . 2>/dev/null || pip install -q . && plato-world-runner run --world $WORLD_NAME --config /config.json"]