feat(agent-challenge): seed platform sdk execution

Author: echobt

docs/operations/validator.md

@@ -98,6 +98,25 @@ Kubernetes mode requires PostgreSQL control-plane state. The installer provides
 registry-scoped `PLATFORM_BROKER_ALLOWED_IMAGES`. SQLite URLs, wildcards, and
 broad prefixes such as `platformnetwork/` fail settings validation.
 
+
+## Agent Challenge Platform SDK Execution Checks
+
+Agent Challenge production Terminal-Bench rollout uses `platform_sdk` through the generic Platform broker. The public proxy must still expose only challenge public routes and must block `/internal/*`, `POST /internal/v1/submissions/{submission_id}/launch`, and generic benchmark execution-shaped routes such as `/benchmark-executions`; the broker is an internal execution substrate, not a public miner API.
+
+Use placeholder commands only and avoid printing token values:
+
+```bash
+kubectl -n <validator-namespace> get pods -l app.kubernetes.io/name=agent-challenge
+kubectl -n <validator-namespace> logs deployment/<agent-challenge-deployment> --since=30m | rg 'terminal_bench|platform_sdk|tb_running'
+kubectl -n <validator-namespace> logs deployment/<platform-broker-deployment> --since=30m | rg 'run request|created job|agent-challenge-terminal-bench-runner'
+kubectl -n <validator-namespace> logs deployment/<agent-challenge-deployment> --since=30m | rg -- '--environment-import-path agent_challenge_runner.platform_environment:PlatformEnvironment'
+! kubectl -n <validator-namespace> logs deployment/<agent-challenge-deployment> --since=30m | rg --fixed-strings -- '--env daytona'
+! kubectl -n <validator-namespace> logs deployment/<agent-challenge-deployment> --since=30m | rg --fixed-strings -- '--env platform'
+curl -sS '<api-base-url>/submissions/<submission-id>/status' | rg '"status":"evaluating"|"phase":"evaluation"|"status":"valid"|"status":"error"'
+```
+
+Safe Agent Challenge knobs are `CHALLENGE_TERMINAL_BENCH_EXECUTION_BACKEND=platform_sdk`, broker URL plus token file, `CHALLENGE_PLATFORM_SDK_RUNNER_IMAGE=ghcr.io/platformnetwork/agent-challenge-terminal-bench-runner:latest`, `CHALLENGE_PLATFORM_SDK_ENVIRONMENT_IMPORT_PATH=agent_challenge_runner.platform_environment:PlatformEnvironment`, and a scoped allowed-image policy. Platform SDK Harbor commands use `--environment-import-path`, not `--env platform`, and production does not require Daytona credentials. Roll back to `harbor` only for non-production testing or for an explicitly credentialed legacy Harbor environment; production remains `platform_sdk` after rollout.
+
 ## Validation
 
 ```bash

src/platform_network/cli_app/main.py

@@ -44,6 +44,7 @@
     ChallengeResources,
     ChallengeSpec,
     DockerOrchestrator,
+    worker_command_from_metadata,
 )
 from platform_network.master.kubernetes_broker import (
     KubernetesBrokerRouterService,
@@ -184,6 +185,9 @@ async def _spec(self, slug: str) -> ChallengeSpec:
             env=record.env,
             resources=ChallengeResources.from_mapping(record.resources),
             required_capabilities=tuple(record.required_capabilities),
+            worker_command=worker_command_from_metadata(
+                getattr(record, "metadata", {}) or {}
+            ),
         )
 
     async def pull(self, slug: str):
@@ -373,6 +377,12 @@ async def _run_master_weight_epoch_response(
 
 PRISM_SLUG = "prism"
 AGENT_CHALLENGE_SLUG = "agent-challenge"
+AGENT_CHALLENGE_TERMINAL_BENCH_RUNNER_IMAGE = (
+    "ghcr.io/platformnetwork/agent-challenge-terminal-bench-runner:latest"
+)
+AGENT_CHALLENGE_PLATFORM_ENVIRONMENT_IMPORT_PATH = (
+    "agent_challenge_runner.platform_environment:PlatformEnvironment"
+)
 PRISM_IMAGE = "ghcr.io/platformnetwork/prism:latest"
 PRISM_EVALUATOR_IMAGE = "ghcr.io/platformnetwork/prism-evaluator:latest"
 PRISM_VERSION = "0.1.0"
@@ -401,6 +411,28 @@ def _prism_image_for_settings(image: str, settings: Any | None) -> str:
     return reference.pinned(resolve_remote_digest(reference))
 
 
+def _agent_challenge_platform_sdk_env(settings: Any | None) -> dict[str, str]:
+    broker_url = _settings_docker_broker_url(settings)
+    docker_broker_token_file = f"{DEFAULT_SECRET_MOUNT_DIR}/docker_broker_token"
+    return {
+        "CHALLENGE_BENCHMARK_BACKEND": "terminal_bench",
+        "CHALLENGE_DOCKER_ENABLED": "true",
+        "CHALLENGE_DOCKER_BACKEND": "broker",
+        "CHALLENGE_DOCKER_BROKER_URL": broker_url,
+        "CHALLENGE_DOCKER_BROKER_TOKEN_FILE": docker_broker_token_file,
+        "CHALLENGE_DOCKER_NETWORK": "default",
+        "CHALLENGE_HARBOR_ENV": "",
+        "CHALLENGE_HARBOR_INSTALL_MODE": "prebuilt",
+        "CHALLENGE_PLATFORM_SDK_ENVIRONMENT_IMPORT_PATH": (
+            AGENT_CHALLENGE_PLATFORM_ENVIRONMENT_IMPORT_PATH
+        ),
+        "CHALLENGE_PLATFORM_SDK_RUNNER_IMAGE": (
+            AGENT_CHALLENGE_TERMINAL_BENCH_RUNNER_IMAGE
+        ),
+        "CHALLENGE_TERMINAL_BENCH_EXECUTION_BACKEND": "platform_sdk",
+    }
+
+
 def prism_challenge_create(settings: Any | None = None) -> ChallengeCreate:
     challenge_token_file = f"{DEFAULT_SECRET_MOUNT_DIR}/challenge_token"
     docker_broker_token_file = f"{DEFAULT_SECRET_MOUNT_DIR}/docker_broker_token"
@@ -475,10 +507,23 @@ async def seed_prism_challenges(
     except (ChallengeNotFoundError, KeyError):
         result[AGENT_CHALLENGE_SLUG] = "missing"
     else:
+        record = await _resolve(registry.get(AGENT_CHALLENGE_SLUG))
+        metadata = dict(getattr(record, "metadata", {}) or {})
+        metadata["worker_command"] = ["agent-challenge-worker"]
+        env = dict(getattr(record, "env", {}) or {})
+        env.update(_agent_challenge_platform_sdk_env(settings))
+        required_capabilities = set(getattr(record, "required_capabilities", []) or [])
+        required_capabilities.update({"docker_executor", "get_weights", "proxy_routes"})
         await _resolve(
             registry.update(
                 AGENT_CHALLENGE_SLUG,
-                ChallengeUpdate(emission_percent=AGENT_CHALLENGE_EMISSION_PERCENT),
+                ChallengeUpdate(
+                    emission_percent=AGENT_CHALLENGE_EMISSION_PERCENT,
+                    env=env,
+                    metadata=metadata,
+                    required_capabilities=sorted(required_capabilities),
+                    secrets=["challenge_token", "docker_broker_token"],
+                ),
             )
         )
         result[AGENT_CHALLENGE_SLUG] = "updated"
@@ -923,12 +968,18 @@ async def refresh() -> None:
                         if settings.kubernetes.challenge_mode == "statefulset"
                         else "Deployment"
                     )
-                    kube_client.patch_workload_image(
-                        kind=workload_kind,
-                        name=workload_name,
-                        container="challenge",
-                        image=desired,
-                    )
+                    containers = ["challenge"]
+                    if worker_command_from_metadata(
+                        getattr(record, "metadata", {}) or {}
+                    ):
+                        containers.append("worker")
+                    for container in containers:
+                        kube_client.patch_workload_image(
+                            kind=workload_kind,
+                            name=workload_name,
+                            container=container,
+                            image=desired,
+                        )
                     typer.echo(
                         f"{record.slug}: patched {workload_kind}/{workload_name}"
                     )

src/platform_network/master/docker_orchestrator.py

@@ -14,6 +14,7 @@
 import re
 import stat
 import time
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
@@ -141,6 +142,7 @@ class ChallengeSpec:
     required_capabilities: tuple[str, ...] = ("get_weights", "proxy_routes")
     expected_api_version: str = DEFAULT_API_VERSION
     port: int = DEFAULT_CHALLENGE_PORT
+    worker_command: tuple[str, ...] = ()
 
     @property
     def safe_slug(self) -> str:
@@ -180,6 +182,20 @@ def all_secrets(self) -> dict[str, str]:
         return secrets
 
 
+def worker_command_from_metadata(metadata: Mapping[str, Any]) -> tuple[str, ...]:
+    raw = metadata.get("worker_command")
+    if raw is None:
+        return ()
+    if isinstance(raw, str) or not isinstance(raw, Sequence):
+        raise DockerOrchestrationError("worker_command metadata must be a string list")
+    command = tuple(raw)
+    if not command or any(not isinstance(item, str) or not item for item in command):
+        raise DockerOrchestrationError(
+            "worker_command metadata must be a non-empty string list"
+        )
+    return command
+
+
 @dataclass(frozen=True)
 class ChallengeRuntime:
     """In-memory runtime state for a started challenge."""

src/platform_network/validator/normal_runner.py

@@ -12,6 +12,7 @@
 from platform_network.master.docker_orchestrator import (
     ChallengeResources,
     ChallengeSpec,
+    worker_command_from_metadata,
 )
 from platform_network.schemas.challenge import ChallengeStatus
 from platform_network.schemas.weights import MasterWeightsResponse
@@ -53,6 +54,9 @@ async def run_once(self) -> None:
                 env=challenge.env,
                 resources=ChallengeResources.from_mapping(challenge.resources),
                 required_capabilities=tuple(challenge.required_capabilities),
+                worker_command=worker_command_from_metadata(
+                    getattr(challenge, "metadata", {}) or {}
+                ),
             )
             self.orchestrator.start_challenge(spec)
 

tests/unit/test_client_service_cli_config.py

@@ -263,6 +263,7 @@ async def get_weights(self, **kwargs: object) -> ChallengeWeightsResult:
         volumes={},
         env={},
         secrets=[],
+        metadata={"worker_command": ["agent-challenge-worker"]},
     )
     setter = Setter()
     service = MasterWeightService(
@@ -293,6 +294,7 @@ def start_challenge(self, spec):
     assert orchestrator.specs[0].slug == "demo"
     assert orchestrator.specs[0].resources.cpu == 2.0
     assert orchestrator.specs[0].resources.memory == "1g"
+    assert orchestrator.specs[0].worker_command == ("agent-challenge-worker",)
 
 
 @pytest.mark.asyncio
@@ -527,6 +529,7 @@ def test_cli_create_and_runtime_controller(tmp_path: Path) -> None:
             image="ghcr.io/o/demo:1",
             version="1",
             resources={"cpus": "1.5", "memory": "2g"},
+            metadata={"worker_command": ["agent-challenge-worker"]},
         )
     )
 
@@ -549,6 +552,7 @@ def restart_challenge(self, spec):
     assert asyncio.run(controller.restart("demo"))["detail"] == "challenge-demo"
     assert orchestrator.specs[0].resources.cpu == 1.5
     assert orchestrator.specs[0].resources.memory == "2g"
+    assert orchestrator.specs[0].worker_command == ("agent-challenge-worker",)
     assert asyncio.run(controller.status("demo"))["status"] == "unknown"
 
 
@@ -1441,6 +1445,30 @@ def test_seed_prism_challenges_is_idempotent_and_preserves_tokens() -> None:
     assert "token" not in prism.metadata
     assert "database_url" not in prism.metadata
     assert agent.emission_percent == Decimal("15")
+    assert agent.metadata["worker_command"] == ["agent-challenge-worker"]
+    assert agent.required_capabilities == [
+        "docker_executor",
+        "get_weights",
+        "proxy_routes",
+    ]
+    assert agent.secrets == ["challenge_token", "docker_broker_token"]
+    assert agent.env["CHALLENGE_BENCHMARK_BACKEND"] == "terminal_bench"
+    assert agent.env["CHALLENGE_DOCKER_ENABLED"] == "true"
+    assert agent.env["CHALLENGE_DOCKER_BACKEND"] == "broker"
+    assert agent.env["CHALLENGE_DOCKER_BROKER_URL"] == "http://platform-broker:8082"
+    assert agent.env["CHALLENGE_DOCKER_BROKER_TOKEN_FILE"] == (
+        "/run/secrets/platform/docker_broker_token"
+    )
+    assert agent.env["CHALLENGE_DOCKER_NETWORK"] == "default"
+    assert agent.env["CHALLENGE_HARBOR_ENV"] == ""
+    assert agent.env["CHALLENGE_HARBOR_INSTALL_MODE"] == "prebuilt"
+    assert agent.env["CHALLENGE_PLATFORM_SDK_ENVIRONMENT_IMPORT_PATH"] == (
+        "agent_challenge_runner.platform_environment:PlatformEnvironment"
+    )
+    assert agent.env["CHALLENGE_PLATFORM_SDK_RUNNER_IMAGE"] == (
+        "ghcr.io/platformnetwork/agent-challenge-terminal-bench-runner:latest"
+    )
+    assert agent.env["CHALLENGE_TERMINAL_BENCH_EXECUTION_BACKEND"] == "platform_sdk"
 
 
 def test_seed_prism_challenges_pins_images_for_production_policy(
@@ -1588,6 +1616,78 @@ def patch_workload_image(self, **kwargs: object) -> None:
     assert "demo: patched StatefulSet/challenge-demo" in result.output
 
 
+def test_master_refresh_challenge_images_patches_worker_container_when_configured(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    digest = "sha256:" + "a" * 64
+    image = f"ghcr.io/platformnetwork/agent-challenge:latest@{digest}"
+    patches: list[dict[str, object]] = []
+
+    class Registry:
+        async def list(self):
+            return [
+                SimpleNamespace(
+                    slug="agent-challenge",
+                    image=image,
+                    status=ChallengeStatus.ACTIVE,
+                    metadata={"worker_command": ["agent-challenge-worker"]},
+                )
+            ]
+
+        async def update(self, slug: str, update: object) -> None:
+            raise AssertionError("already-current image must not update registry")
+
+    class KubeClient:
+        def __init__(self, **kwargs: object) -> None:
+            patches.append({"init": kwargs})
+
+        def patch_workload_image(self, **kwargs: object) -> None:
+            patches.append(kwargs)
+
+    settings = SimpleNamespace(
+        runtime=SimpleNamespace(backend="kubernetes"),
+        kubernetes=SimpleNamespace(
+            namespace="platform-master",
+            in_cluster=True,
+            kubeconfig=None,
+            challenge_mode="statefulset",
+        ),
+    )
+
+    import platform_network.kubernetes.client as kube_module
+    import platform_network.validator.image_updater as image_updater_module
+
+    monkeypatch.setattr(cli_module, "load_settings", lambda config: settings)
+    monkeypatch.setattr(cli_module, "_master_registry", lambda settings: Registry())
+    monkeypatch.setattr(
+        cli_module, "_challenge_orchestrator", lambda settings: object()
+    )
+    monkeypatch.setattr(kube_module, "KubernetesClient", KubeClient)
+    monkeypatch.setattr(
+        image_updater_module,
+        "resolve_remote_digest",
+        lambda image_reference: digest,
+    )
+
+    result = CliRunner().invoke(
+        app, ["master", "refresh-challenge-images", "--config", "unused.yaml"]
+    )
+
+    assert result.exit_code == 0, result.output
+    assert {
+        "kind": "StatefulSet",
+        "name": "challenge-agent-challenge",
+        "container": "challenge",
+        "image": image,
+    } in patches
+    assert {
+        "kind": "StatefulSet",
+        "name": "challenge-agent-challenge",
+        "container": "worker",
+        "image": image,
+    } in patches
+
+
 def test_registry_client_with_asgi_transport(monkeypatch: pytest.MonkeyPatch) -> None:
     async def handler(request: httpx.Request) -> httpx.Response:
         return httpx.Response(