Phase 2 validation

Dockerfile

@@ -1,11 +1,9 @@
-# Use official lightweight Python image
 # REBUILD_TIMESTAMP: 2026-04-07 23:30 (Phase2 Fix: /health=healthy, /metadata, /schema, /mcp, httpx)
-FROM python:3.10-slim
+FROM ghcr.io/meta-pytorch/openenv-base:latest
 
-# Set working directory
 WORKDIR /app
 
-# Install system dependencies (git for building packages if needed)
+# Install system dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
     git \
     && rm -rf /var/lib/apt/lists/*
@@ -14,17 +12,21 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY . .
 
 # Install the package and its dependencies
-# pip install -e . uses the pyproject.toml in the current directory
 RUN pip install --no-cache-dir -e .
 RUN pip install --no-cache-dir uvicorn fastapi
 
-# Expose the API port (standard for HF Spaces or custom)
-EXPOSE 8000
-
-# Set environment variables for better logging
+# Set environment variables for better logging and robustness
 ENV PYTHONUNBUFFERED=1
 ENV HF_HOME=/tmp/.cache
+ENV PYTHONPATH="/app:$PYTHONPATH"
+
+# Expose the API port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
 
 # Command to run the FastAPI server
-# This calls the main function in server/app.py which starts uvicorn
-CMD ["python", "server/app.py", "--host", "0.0.0.0", "--port", "8000"]
+# Running from /app ensures server.app:app resolves correctly
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]

check_graders.py

@@ -42,28 +42,19 @@ def check_graders():
             
             module_path, func_name = grader_str.split(":")
             
-            module = None
-            # Try full path first (as it will be in the platform)
+            # Simple direct import (no fallback, must be robust)
             try:
                 module = importlib.import_module(module_path)
-            except ImportError:
-                # Local fallback: try without 'drone_env.' prefix if we're in the project root
-                if module_path.startswith("drone_env."):
-                    alt_path = module_path.replace("drone_env.", "", 1)
-                    try:
-                        module = importlib.import_module(alt_path)
-                    except ImportError as eb:
-                        print(f"  ❌ Module search failed (tried {module_path} and {alt_path}): {eb}")
+                if module:
+                    func = getattr(module, func_name, None)
+                    if func and callable(func):
+                        print(f"  ✅ SUCCESS: Found {func_name} in {module.__name__}")
+                        valid_count += 1
+                    else:
+                        print(f"  ❌ {func_name} not found or not callable in {module.__name__}")
+            except ImportError as e:
+                print(f"  ❌ Module import failed: {e}")
             
-            if module:
-                func = getattr(module, func_name, None)
-                if func and callable(func):
-                    print(f"  ✅ SUCCESS: Found {func_name} in {module.__name__}")
-                    valid_count += 1
-                else:
-                    print(f"  ❌ {func_name} not found or not callable in {module.__name__}")
-            else:
-                pass # Already printed error
         except Exception as e:
             print(f"  ❌ Error: {e}")
 

core/tasks.py

@@ -4,7 +4,7 @@ Mission configurations for Drone Delivery missions.
 """
 
 TASK_CONFIG = {
-    "drone_env.graders.easy:grade_easy": {
+    "graders:grade_easy": {
         "width": 10,
         "height": 10,
         "n_buildings": 4,
@@ -24,7 +24,7 @@ TASK_CONFIG = {
         "r_wall": 0.10,
         "r_blocked": 0.10,
     },
-    "drone_env.graders.medium:grade_medium": {
+    "graders:grade_medium": {
         "width": 14,
         "height": 14,
         "n_buildings": 8,
@@ -44,7 +44,7 @@ TASK_CONFIG = {
         "r_wall": 0.15,
         "r_blocked": 0.15,
     },
-    "drone_env.graders.hard:grade_hard": {
+    "graders:grade_hard": {
         "width": 18,
         "height": 18,
         "n_buildings": 12,

graders.py

@@ -0,0 +1,57 @@
+"""
+Unified graders for Drone Delivery OpenEnv.
+All grading functions are consolidated here for reliable importing during validation.
+"""
+
+def _get_attr(state, key, default=0):
+    """Safely get an attribute from a state object or dict."""
+    if isinstance(state, dict):
+        return state.get(key, default)
+    return getattr(state, key, default)
+
+
+def compute_grade(state, max_steps: float) -> float:
+    """
+    Unified grade calculation:
+    - 80% weighted by deliveries completed.
+    - 20% weighted by efficiency (remaining battery and steps).
+    """
+    deliveries_total = _get_attr(state, "deliveries_total", 0)
+    deliveries_done  = _get_attr(state, "deliveries_done",  0)
+    battery          = _get_attr(state, "battery",          1.0)
+    step_count       = _get_attr(state, "step_count",       0)
+
+    if deliveries_total == 0:
+        return 0.5
+
+    delivery_ratio = deliveries_done / deliveries_total
+    efficiency = float(battery) * 0.5 + (1.0 - (float(step_count) / float(max_steps))) * 0.5
+    efficiency = max(0.0, min(1.0, efficiency))
+
+    score = (delivery_ratio * 0.8) + (efficiency * 0.2)
+    if deliveries_done < deliveries_total:
+        score = min(score, 0.49)
+
+    return max(0.01, min(0.99, float(score)))
+
+
+def grade_easy(state) -> float:
+    """Grader for easy_delivery task (10x10 grid, 1 delivery, 60 max steps)."""
+    return compute_grade(state, 60.0)
+
+
+def grade_medium(state) -> float:
+    """Grader for medium_delivery task (14x14 grid, 3 deliveries, 100 max steps)."""
+    return compute_grade(state, 100.0)
+
+
+def grade_hard(state) -> float:
+    """Grader for hard_delivery task (18x18 grid, 5 deliveries, 160 max steps)."""
+    return compute_grade(state, 160.0)
+
+# --- Standardization Mapping ---
+GRADERS = {
+    "graders:grade_easy": grade_easy,
+    "graders:grade_medium": grade_medium,
+    "graders:grade_hard": grade_hard,
+}

graders/__init__.py

@@ -3,9 +3,9 @@ from .medium import grade_medium
 from .hard import grade_hard
 
 GRADERS = {
-    "drone_env.graders.easy:grade_easy": grade_easy,
-    "drone_env.graders.medium:grade_medium": grade_medium,
-    "drone_env.graders.hard:grade_hard": grade_hard,
+    "graders:grade_easy": grade_easy,
+    "graders:grade_medium": grade_medium,
+    "graders:grade_hard": grade_hard,
 }
 
 __all__ = ["grade_easy", "grade_medium", "grade_hard", "GRADERS"]

inference.py

@@ -2,7 +2,7 @@
 SkyRelic Drone Delivery: Standardized Inference Script
 ===================================================
 MANDATORY
-- Environment variables: HF_TOKEN, API_BASE_URL, MODEL_NAME
+- All 3 tasks (easy, medium, hard) are executed sequentially to satisfy Phase 2 validation.
 - STDOUT FORMAT: [START], [STEP], [END]
 - Participants must use OpenAI Client for all LLM calls.
 """
@@ -10,101 +10,103 @@ MANDATORY
 import asyncio
 import os
 import textwrap
+import json
 import sys
 from typing import List, Optional
 from pathlib import Path
-
+from pydantic import BaseModel, Field
 from openai import OpenAI
 
-# Local Project Imports
+# Unified Imports - Canonical Package Paths with local fallbacks
 ROOT_DIR = Path(__file__).parent
 if str(ROOT_DIR) not in sys.path:
     sys.path.insert(0, str(ROOT_DIR))
 
-# Load .env for local development convenience
-def load_dotenv(path: Path):
-    if path.exists():
-        for line in path.read_text().splitlines():
+try:
+    from models import DroneAction, DroneObservation
+    from server.grid_world_environment import DroneDeliveryEnvironment
+except ImportError:
+    # Use fallback if not found in root
+    from drone_env.models import DroneAction, DroneObservation
+    from drone_env.server.grid_world_environment import DroneDeliveryEnvironment
+
+# --- Load .env file for local development ---
+def load_dotenv():
+    env_path = Path(__file__).parent / ".env"
+    if env_path.exists():
+        for line in env_path.read_text().splitlines():
             line = line.strip()
-            if not line or line.startswith("#") or "=" not in line: continue
-            k, v = line.split("=", 1)
-            os.environ[k.strip()] = v.strip().strip('"').strip("'")
-load_dotenv(ROOT_DIR / ".env")
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, value = line.split("=", 1)
+            os.environ[key.strip()] = value.strip().strip('"').strip("'")
 
-# Use the established Drone Environment
-from drone_env.server.grid_world_environment import DroneDeliveryEnvironment
-from drone_env.models import DroneAction, DroneObservation
+load_dotenv()
 
 # --- Configuration ------------------------------------------------------------
-IMAGE_NAME = os.getenv("IMAGE_NAME") or os.getenv("LOCAL_IMAGE_NAME")
-# Use a placeholder if no key is found to prevent initialization crash during local tests
+IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
 API_KEY = os.getenv("HF_TOKEN") or os.getenv("API_KEY") or os.getenv("OPENAI_API_KEY") or "EMPTY_KEY"
-
-# Defaults are set only for API_BASE_URL and MODEL_NAME as per requirements
 API_BASE_URL = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
 MODEL_NAME = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-7B-Instruct"
 
-TASK_MAP = {
-    "easy": "drone_env.graders.easy:grade_easy",
-    "medium": "drone_env.graders.medium:grade_medium",
-    "hard": "drone_env.graders.hard:grade_hard",
-    "easy_delivery": "drone_env.graders.easy:grade_easy",
-    "medium_delivery": "drone_env.graders.medium:grade_medium",
-    "hard_delivery": "drone_env.graders.hard:grade_hard",
-}
-
-# Accepts "easy", "medium", "hard" or the full grader path
-RAW_TASK = os.getenv("TASK_NAME", "easy")
-TASK_NAME = TASK_MAP.get(RAW_TASK, RAW_TASK)
-
-BENCHMARK = os.getenv("DRONE_BENCHMARK", "drone_env_v1")
-
-MAX_STEPS = 60 # Default fallback
-TEMPERATURE = 0.0
-MAX_TOKENS = 50
-SUCCESS_SCORE_THRESHOLD = 0.5
-
-SYSTEM_PROMPT = textwrap.dedent(
-    """
-    You are a drone navigation AI. Your goal is to deliver packages to targets.
-    Each turn, you receive the drone's position, battery, target, and distance.
-    Valid Actions: UP, DOWN, LEFT, RIGHT, WAIT.
-    Respond with exactly one action name in uppercase. No quotes.
-    """
-).strip()
+BENCHMARK = "drone_env"
+ALL_TASKS = ["easy_delivery", "medium_delivery", "hard_delivery"]
+TEMPERATURE = 0.7
+
+# --- Structured output schema ------------------------------------------------
+
+class NavigationAction(BaseModel):
+    """Structured navigation action output from the LLM."""
+    reasoning: str = Field(description="Brief explanation of why this direction was chosen")
+    direction: str = Field(description="Movement direction: UP, DOWN, LEFT, RIGHT, or WAIT")
+
+# --- Prompts ------------------------------------------------------------------
+
+SYSTEM_PROMPT = textwrap.dedent("""
+    You are a drone navigation AI. Your goal is to deliver packages to targets in a grid world.
+    
+    Grid Mechanics:
+    - (x, y) coordinates: x increases right, y increases down.
+    - UP: y decreases
+    - DOWN: y increases
+    - LEFT: x decreases
+    - RIGHT: x increases
+    
+    Constraints:
+    - Avoid buildings and obstacles.
+    - Battery drains per move.
+    
+    You MUST respond with a valid JSON object:
+    {"reasoning": "<brief explanation>", "direction": "UP|DOWN|LEFT|RIGHT|WAIT"}
+""").strip()
+
+def build_user_prompt(obs: DroneObservation) -> str:
+    return textwrap.dedent(f"""
+        Pos: ({obs.drone_x}, {obs.drone_y})
+        Battery: {obs.battery:.2f}
+        Target: {obs.current_target}
+        Distance: {obs.distance_to_target:.1f}
+        Status: {obs.message}
+        
+        Plan your next move to reach the target efficiently.
+    """).strip()
 
 # --- Logging Helpers ---------------------------------------------------------
+
 def log_start(task: str, env: str, model: str) -> None:
     print(f"[START] task={task} env={env} model={model}", flush=True)
 
 def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
     error_val = error if error else "null"
-    done_val = str(done).lower()
-    # Format reward to 2 decimal places as per requirement
-    print(
-        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
-        flush=True,
-    )
+    print(f"[STEP] step={step} action={action} reward={reward:.2f} done={str(done).lower()} error={error_val}", flush=True)
 
 def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
-    # Format rewards to 2 decimal places as per requirement
     rewards_str = ",".join(f"{r:.2f}" for r in rewards)
     print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
 
 # --- Agent Logic -------------------------------------------------------------
-def build_user_prompt(obs: DroneObservation) -> str:
-    return textwrap.dedent(
-        f"""
-        Pos: ({obs.drone_x}, {obs.drone_y})
-        Battery: {obs.battery:.2f}
-        Target: {obs.current_target}
-        Distance: {obs.distance_to_target:.1f}
-        Status: {obs.message}
-        Available Actions: UP, DOWN, LEFT, RIGHT, WAIT
-        """
-    ).strip()
 
-def get_model_action(client: OpenAI, obs: DroneObservation) -> str:
+def get_action(client: OpenAI, obs: DroneObservation) -> NavigationAction:
     user_prompt = build_user_prompt(obs)
     try:
         completion = client.chat.completions.create(
@@ -114,70 +116,77 @@ def get_model_action(client: OpenAI, obs: DroneObservation) -> str:
                 {"role": "user", "content": user_prompt},
             ],
             temperature=TEMPERATURE,
-            max_tokens=MAX_TOKENS,
-            stream=False,
+            response_format={"type": "json_object"},
         )
-        text = (completion.choices[0].message.content or "").strip().upper()
-        if text not in ["UP", "DOWN", "LEFT", "RIGHT", "WAIT"]:
-            return "WAIT"
-        return text
+        raw = completion.choices[0].message.content or "{}"
+        data = json.loads(raw)
+        action = NavigationAction(
+            reasoning=data.get("reasoning", ""),
+            direction=data.get("direction", "WAIT").upper(),
+        )
+        if action.direction not in ["UP", "DOWN", "LEFT", "RIGHT", "WAIT"]:
+            action.direction = "WAIT"
+        return action
     except Exception as exc:
-        print(f"[DEBUG] Model request failed: {exc}", file=sys.stderr, flush=True)
-        return "WAIT"
+        print(f"[DEBUG] Model request failed: {exc}", flush=True)
+        return NavigationAction(reasoning="fallback", direction="WAIT")
 
 # --- Run Loop ----------------------------------------------------------------
-async def main() -> None:
-    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-
-    # Initialize environment locally
-    # Note: the sample template uses docker integration, but for local 
-    # hackathon development, we initialize the DroneDeliveryEnvironment directly.
-    env = DroneDeliveryEnvironment()
 
-    history: List[str] = []
+async def run_task(task_id: str, env: DroneDeliveryEnvironment, client: OpenAI) -> float:
     rewards: List[float] = []
     steps_taken = 0
-    score = 0.010
+    score = 0.01
     success = False
 
-    log_start(task=TASK_NAME, env=BENCHMARK, model=MODEL_NAME)
+    log_start(task=task_id, env=BENCHMARK, model=MODEL_NAME)
 
     try:
-        # Initial reset
-        obs = env.reset(DroneAction(task_name=TASK_NAME))
-        
-        # Max steps from environment or local constant
-        max_limit = int(obs.max_steps) if obs.max_steps else MAX_STEPS
+        obs = env.reset(DroneAction(task_name=task_id))
+        max_steps = int(obs.max_steps) if obs.max_steps else 60
 
-        for step in range(1, max_limit + 1):
+        for step in range(1, max_steps + 1):
             if obs.done:
                 break
 
-            action_str = get_model_action(client, obs)
-
-            # Step environment
+            nav_action = get_action(client, obs)
+            action_str = nav_action.direction
+            
             obs = env.step(DroneAction(direction=action_str))
-
+            
             reward = float(obs.reward_last)
             done = bool(obs.done)
-            error = None
-
+            
             rewards.append(reward)
             steps_taken = step
-
-            log_step(step=step, action=action_str, reward=reward, done=done, error=error)
+            log_step(step=step, action=action_str, reward=reward, done=done, error=None)
 
             if done:
                 break
 
-        # Final score (already normalized by the environment's grader [0.01, 0.99])
-        score = float(obs.score) if obs.score is not None else 0.010
+        score = float(obs.score) if obs.score is not None else 0.01
         success = (obs.deliveries_done == obs.deliveries_total) and obs.deliveries_total > 0
 
+    except Exception as e:
+        print(f"[DEBUG] run_task({task_id}) error: {e}", flush=True)
+
     finally:
-        # Mandatory close and log emission
         log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+        print(f"\n{'='*50}", flush=True)
+        print(f"  Task        : {task_id}", flush=True)
+        print(f"  Total Steps : {steps_taken}", flush=True)
+        print(f"  Final Score : {score:.3f}", flush=True)
+        print(f"  Success     : {success}", flush=True)
+        print(f"{'='*50}\n", flush=True)
+
+    return score
+
+async def main() -> None:
+    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    env = DroneDeliveryEnvironment()
 
+    for task_id in ALL_TASKS:
+        await run_task(task_id, env, client)
 
 if __name__ == "__main__":
     asyncio.run(main())

models.py

@@ -14,7 +14,7 @@ class DroneAction(BaseModel):
     )
     task_name: Optional[str] = Field(
         default=None,
-        description="Task to load on reset: drone_env.graders.easy:grade_easy | medium | hard",
+        description="Task to load on reset: graders:grade_easy | medium | hard",
     )
 
 
@@ -43,7 +43,7 @@ class DroneObservation(BaseModel):
 
 class DroneState(BaseModel):
     episode_id: str = ""
-    task_name: str = "drone_env.graders.easy:grade_easy"
+    task_name: str = "graders:grade_easy"
     step_count: int = 0
     done: bool = False
     reward_total: float = 0.0

openenv.yaml

@@ -6,8 +6,8 @@ app: server.app:app
 port: 8000
 tasks:
   - id: easy_delivery
-    grader: drone_env.graders.easy:grade_easy
+    grader: graders:grade_easy
   - id: medium_delivery
-    grader: drone_env.graders.medium:grade_medium
+    grader: graders:grade_medium
   - id: hard_delivery
-    grader: drone_env.graders.hard:grade_hard
+    grader: graders:grade_hard

server/app.py

@@ -21,13 +21,22 @@ BASE_DIR = Path(__file__).parent.parent
 if str(BASE_DIR) not in sys.path:
     sys.path.insert(0, str(BASE_DIR))
 
-# Unified Imports - Canonical Package Paths
-from drone_env.models import DroneAction, DroneObservation, DroneState
-from drone_env.server.grid_world_environment import DroneDeliveryEnvironment
-from drone_env.core.tasks import TASK_CONFIG
-from drone_env.graders import GRADERS
+# Unified Imports - Canonical Package Paths with local fallbacks
+try:
+    from drone_env.models import DroneAction, DroneObservation, DroneState
+    from drone_env.server.grid_world_environment import DroneDeliveryEnvironment
+    from drone_env.core.tasks import TASK_CONFIG
+    import graders as graders_mod
+except ImportError:
+    from models import DroneAction, DroneObservation, DroneState
+    from server.grid_world_environment import DroneDeliveryEnvironment
+    from core.tasks import TASK_CONFIG
+    import graders as graders_mod
+
 from drone_env.rl.trainer import PathLearner, get_action_from_policy
 
+from graders import GRADERS
+
 app = FastAPI(
     title="Drone Delivery OpenEnv",
     description="Real-world drone delivery RL environment.",
@@ -86,11 +95,11 @@ async def metadata():
     return {
         "name": "drone_env",
         "description": "SkyRelic Drone Delivery reinforcement-learning environment with easy/medium/hard delivery tasks on a grid world.",
-        "version": "0.2.1",
+        "version": "0.2.2",
         "tasks": [
-            {"id": "easy_delivery",  "grader": "drone_env.graders.easy:grade_easy"},
-            {"id": "medium_delivery", "grader": "drone_env.graders.medium:grade_medium"},
-            {"id": "hard_delivery",  "grader": "drone_env.graders.hard:grade_hard"},
+            {"id": "easy_delivery",   "grader": "graders:grade_easy"},
+            {"id": "medium_delivery", "grader": "graders:grade_medium"},
+            {"id": "hard_delivery",   "grader": "graders:grade_hard"},
         ],
     }
 
@@ -144,9 +153,18 @@ async def get_state():
 
 # Task ID → grader key mapping (matches openenv.yaml task ids)
 TASK_ID_TO_GRADER = {
-    "easy_delivery":  "drone_env.graders.easy:grade_easy",
-    "medium_delivery": "drone_env.graders.medium:grade_medium",
-    "hard_delivery":  "drone_env.graders.hard:grade_hard",
+    # Short IDs
+    "easy_delivery":   "graders:grade_easy",
+    "medium_delivery": "graders:grade_medium",
+    "hard_delivery":   "graders:grade_hard",
+    # Standardized keys (as IDs)
+    "graders:grade_easy":   "graders:grade_easy",
+    "graders:grade_medium": "graders:grade_medium",
+    "graders:grade_hard":   "graders:grade_hard",
+    # Legacy support for old cached browser sessions
+    "drone_env.graders.easy:grade_easy":   "graders:grade_easy",
+    "drone_env.graders.medium:grade_medium": "graders:grade_medium",
+    "drone_env.graders.hard:grade_hard":   "graders:grade_hard",
 }
 
 @app.get("/grade/{task_name}")
@@ -207,7 +225,7 @@ async def get_terminal_logs():
 @app.get("/rewards")
 async def get_rewards():
     """Return the reward configuration for the current task."""
-    task_name = _env.state.task_name or "drone_env.graders.easy:grade_easy"
+    task_name = _env.state.task_name or "graders:grade_easy"
     config = TASK_CONFIG.get(task_name, {})
     # Filter only reward keys
     rewards = {k: v for k, v in config.items() if k.startswith("r_")}
@@ -248,7 +266,7 @@ async def get_memory_logs():
 
 @app.post("/predict")
 async def predict(obs: DroneObservation):
-    task_name = _env.state.task_name or "drone_env.graders.easy:grade_easy"
+    task_name = _env.state.task_name or "graders:grade_easy"
     action_str = get_action_from_policy(obs, task_name)
     return {"direction": action_str}
 

server/grid_world_environment.py

@@ -24,7 +24,14 @@ from drone_env.core.tasks import TASK_CONFIG
 from drone_env.core.drone import compute_next_pos, drain_battery
 from drone_env.core.obstacles import check_move
 from drone_env.core.state_manager import new_episode_state
-from drone_env.graders import GRADERS
+try:
+    from drone_env.graders import GRADERS
+except ImportError:
+    try:
+        from graders import GRADERS
+    except ImportError:
+        # Final fallback
+        GRADERS = {}
 from drone_env.rl.trainer import record_episode
 
 
@@ -33,7 +40,7 @@ class DroneDeliveryEnvironment(Environment):
     def __init__(self):
         super().__init__()
         self._state = DroneState()
-        self._cfg = TASK_CONFIG["drone_env.graders.easy:grade_easy"]
+        self._cfg = TASK_CONFIG["graders:grade_easy"]
         self._grid: List[List[str]] = []
         self._deliveries: List[Tuple[int, int]] = []
         self._delivered: List[bool] = []
@@ -51,11 +58,15 @@ class DroneDeliveryEnvironment(Environment):
 
         # Map short task IDs (from openenv.yaml) to full grader keys
         _TASK_ID_MAP = {
-            "easy_delivery":   "drone_env.graders.easy:grade_easy",
-            "medium_delivery": "drone_env.graders.medium:grade_medium",
-            "hard_delivery":   "drone_env.graders.hard:grade_hard",
+            "easy_delivery":   "graders:grade_easy",
+            "medium_delivery": "graders:grade_medium",
+            "hard_delivery":   "graders:grade_hard",
+            # Legacy redirects
+            "drone_env.graders.easy:grade_easy":   "graders:grade_easy",
+            "drone_env.graders.medium:grade_medium": "graders:grade_medium",
+            "drone_env.graders.hard:grade_hard":   "graders:grade_hard",
         }
-        task = "drone_env.graders.easy:grade_easy"
+        task = "graders:grade_easy"
         if action and action.task_name:
             name = action.task_name
             if name in _TASK_ID_MAP:

server/static/index.html

@@ -1230,17 +1230,17 @@
           <div class="panel-inner">
             <div class="panel-title">Mission Select</div>
             <div class="task-group" id="taskGroup">
-              <button class="task-btn active" data-task="drone_env.graders.easy:grade_easy">
+              <button class="task-btn active" data-task="graders:grade_easy">
                 <span class="dot"></span>
                 Easy Delivery
                 <span class="task-tag">10×10</span>
               </button>
-              <button class="task-btn" data-task="drone_env.graders.medium:grade_medium">
+              <button class="task-btn" data-task="graders:grade_medium">
                 <span class="dot"></span>
                 Medium Delivery
                 <span class="task-tag">14×14</span>
               </button>
-              <button class="task-btn" data-task="drone_env.graders.hard:grade_hard">
+              <button class="task-btn" data-task="graders:grade_hard">
                 <span class="dot"></span>
                 Hard Delivery
                 <span class="task-tag">18×18</span>
@@ -1718,7 +1718,7 @@
       }
     </style>
 
-  <script src="/static/script.js"></script>
+  <script src="/static/script.js?v=2.2"></script>
 </body>
 
 </html>

server/static/script.js

@@ -17,7 +17,7 @@ const EMOJI = {
 // ═══════════════════════════════════════════════════════
 //  STATE
 // ═══════════════════════════════════════════════════════
-let currentTask = 'drone_env.graders.easy:grade_easy'; 
+let currentTask = 'graders:grade_easy'; 
 let autoTimer   = null;
 let logTimer    = null;
 let obs         = null;
@@ -601,9 +601,9 @@ function startNextTask() {
     closeCompletionModal();
     
     const sequence = {
-        'drone_env.graders.easy:grade_easy': 'drone_env.graders.medium:grade_medium',
-        'drone_env.graders.medium:grade_medium': 'drone_env.graders.hard:grade_hard',
-        'drone_env.graders.hard:grade_hard': 'drone_env.graders.easy:grade_easy'
+        'graders:grade_easy': 'graders:grade_medium',
+        'graders:grade_medium': 'graders:grade_hard',
+        'graders:grade_hard': 'graders:grade_easy'
     };
     
     const nextTask = sequence[currentTask] || 'drone_env.graders.easy:grade_easy';
@@ -627,7 +627,7 @@ async function updateMissionLegend() {
         if (!container || !data.tasks) return;
         
         // Ensure tasks are sorted Easy, Medium, Hard
-        const order = ['drone_env.graders.easy:grade_easy', 'drone_env.graders.medium:grade_medium', 'drone_env.graders.hard:grade_hard'];
+        const order = ['graders:grade_easy', 'graders:grade_medium', 'graders:grade_hard'];
         const tasks = data.tasks.sort((a, b) => order.indexOf(a.name) - order.indexOf(b.name));
         
         container.innerHTML = `