Production-ready: Clean code with Groq API integration, LoRA model support, and FastAPI app

.dockerignore

@@ -0,0 +1,51 @@
+# VCS metadata
+.git
+.gitignore
+.gitattributes
+
+# Python caches and virtual environments
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+.venv/
+venv/
+env/
+ENV/
+.pytest_cache/
+.mypy_cache/
+.ipynb_checkpoints/
+
+# Editor/system files
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+Thumbs.db
+
+# Build/test outputs
+dist/
+build/
+*.egg-info/
+pip-wheel-metadata/
+htmlcov/
+.coverage
+.coverage.*
+
+# Logs and temp
+*.log
+tmp/
+temp/
+
+# Keep runtime ML artifact, drop bulky generated outputs
+artifacts/*
+!artifacts/ml_policy.pkl
+!artifacts/ml_policy_report.json
+artifacts/sweep/
+artifacts/lookahead_tuning/
+artifacts/inference_*.json
+artifacts/autopilot_*.json
+artifacts/demo_*.json
+artifacts/run_now_*.json

.gitattributes

@@ -0,0 +1,2 @@
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,13 @@
+# Large model files
+*.pkl
+*.safetensors
+*.jsonl
+artifacts/
+flight-rebooking-lora/
+venv/
+__pycache__/
+*.pyc
+.DS_Store
+*.egg-info/
+dist/
+build/

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.10-slim
+
+# Install system dependencies for bitsandbytes
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY app.py .
+COPY environment.py .
+COPY tasks.py .
+COPY openenv.yaml .
+COPY frontend/ ./frontend/
+COPY flight-rebooking-lora/ ./flight-rebooking-lora/
+
+# Create a place for HF cache
+RUN mkdir -p /app/.cache && chmod 777 /app/.cache
+ENV HF_HOME=/app/.cache
+
+EXPOSE 7860
+
+# Start the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,82 @@
+---
+title: Storm Recovery Agent ✈️
+emoji: ⛈️
+colorFrom: indigo
+colorTo: blue
+sdk: docker
+app_port: 7860
+tags:
+  - openenv
+  - simulation
+  - logistics
+  - llama-3
+  - ai-agent
+---
+
+# ✈️ Storm Recovery Agent: Fine-Tuning LLMs for High-Stakes Logistics
+
+> "The storm just cancelled 40 flights. You have 2,000 stranded passengers and only 500 available seats. Who gets home first?"
+
+This is the **Flight Rebooking OpenEnv**, a professional simulation designed to train AI agents to handle the complex, high-stakes trade-offs of airline irregular operations (IROPS).
+
+## 🌟 The Challenge (Theme #3.1: Professional Tasks)
+When weather strikes, human operation desks must balance:
+- **Loyalty SLAs**: Ensuring Platinum and Gold members are prioritized.
+- **Connection Deadlines**: Rebooking passengers before their next vital flight.
+- **Budget Limits**: Deciding when to use expensive partner airlines or hotels.
+- **Inventory Scarcity**: Making every seat count in a zero-sum game.
+
+Generic LLMs often struggle with these "constrained optimization" tasks. This environment provides the structured feedback needed to turn a raw LLM into a **Disruption Specialist**.
+
+## 🧠 The Solution: Fine-Tuned Llama 3 8B
+We didn't just build a simulator; we trained an agent to master it.
+- **Base Model**: Meta Llama-3-8B-Instruct.
+- **Training**: Fine-tuned on **800+ expert trajectories** using LoRA (Unsloth).
+- **Strategy**: The agent learned to prioritize by tier while simultaneously minimizing cost and connection delays.
+
+## 📊 Evidence of Training (20% Weight)
+
+### 📈 Training Progress
+Our agent showed consistent improvement across all metrics. By epoch 3, it mastered the delicate balance between passenger happiness and operational cost.
+
+![Training Progress](artifacts/training_progress.png)
+
+### 🏆 Performance Comparison
+The trained AI Agent now outperforms standard rule-based heuristics, especially in **"Hard" scenarios** where inventory is extremely scarce and requires strategic "triage" decisions.
+
+![Performance Comparison](artifacts/performance_comparison.png)
+
+| Task | Heuristic Baseline | **Trained AI Agent** |
+|------|--------------------|----------------------|
+| Easy | 1.000 | **1.000** |
+| Medium | 0.972 | **0.990** (+2%) |
+| Hard | 0.958 | **0.980** (+2.3%) |
+
+## 🕹️ Interactive Control Tower
+Explore the agent's behavior live on our **Hugging Face Space**!
+- **Live Observation**: Watch the passenger queue and flight inventory update in real-time.
+- **AI Auto-Play**: Watch the fine-tuned Llama 3 model solve disruptions autonomously.
+- **Manual Control**: Test your own rebooking skills against the AI.
+
+[**Launch the Control Tower UI**](https://huggingface.co/spaces/YOUR_USER/flight-rebooking-agent/ui)
+
+## 🏗️ Technical Foundation
+- **Framework**: Built on **OpenEnv** for standard RL/LLM interaction.
+- **Backend**: FastAPI with 4-bit quantization (bitsandbytes) for efficient inference.
+- **Frontend**: Vanilla JS dashboard for real-time state visualization.
+- **Deployment**: Fully containerized with Docker for seamless HF Space integration.
+
+## 🛠️ Local Setup & Evaluation
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the OpenEnv Validator
+python pre_submission_validate.py --skip-docker
+
+# Start the Control Tower locally
+python app.py
+```
+
+---
+*Developed for the Meta PyTorch Hackathon (India 2026).*

app.py

@@ -0,0 +1,230 @@
+import json
+import torch
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+from uuid import uuid4
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, Field
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+from peft import PeftModel
+
+from environment import Action, ActionType, FlightRebookingEnv
+from tasks import TASKS, grade_task
+
+app = FastAPI(
+    title="Flight Rebooking AI Agent",
+    description="AI-powered airline disruption operations agent.",
+    version="2.1.0",
+)
+
+_SESSIONS: Dict[str, Dict[str, Any]] = {}
+_DEFAULT_SESSION_ID = "default"
+_BASE_DIR = Path(__file__).resolve().parent
+_FRONTEND_DIR = _BASE_DIR / "frontend"
+
+# Model Globals
+MODEL = None
+TOKENIZER = None
+
+if _FRONTEND_DIR.exists():
+    app.mount("/ui/static", StaticFiles(directory=str(_FRONTEND_DIR)), name="ui-static")
+
+class CreateSessionRequest(BaseModel):
+    task: str = Field(default="easy", description="One of: easy, medium, hard")
+
+class StepRequest(BaseModel):
+    action: Action
+    session_id: str = Field(default=_DEFAULT_SESSION_ID)
+
+def load_model():
+    global MODEL, TOKENIZER
+    if MODEL is not None:
+        return MODEL, TOKENIZER
+
+    # Check if GPU is available and has enough VRAM (need at least 6GB)
+    if not torch.cuda.is_available():
+        print("⚠️ No CUDA GPU found. AI Auto-Play disabled (heuristic mode only).")
+        MODEL, TOKENIZER = False, False
+        return MODEL, TOKENIZER
+    
+    vram_gb = torch.cuda.get_device_properties(0).total_mem / (1024**3)
+    if vram_gb < 6.0:
+        print(f"⚠️ GPU has {vram_gb:.1f}GB VRAM (need 6GB+). AI Auto-Play disabled.")
+        MODEL, TOKENIZER = False, False
+        return MODEL, TOKENIZER
+
+    base_model_name = "unsloth/llama-3-8b-Instruct-bnb-4bit"
+    adapter_path = "./flight-rebooking-lora"
+    
+    print(f"Loading AI Model: {base_model_name}...")
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_compute_dtype=torch.float16,
+    )
+
+    try:
+        TOKENIZER = AutoTokenizer.from_pretrained(base_model_name)
+        MODEL = AutoModelForCausalLM.from_pretrained(
+            base_model_name,
+            quantization_config=bnb_config,
+            device_map="auto"
+        )
+        if os.path.exists(adapter_path):
+            print(f"Applying LoRA adapters from {adapter_path}")
+            MODEL = PeftModel.from_pretrained(MODEL, adapter_path)
+        MODEL.eval()
+        print("✅ AI Model Loaded Successfully")
+    except Exception as e:
+        print(f"❌ Error loading model: {e}")
+        MODEL, TOKENIZER = False, False
+    
+    return MODEL, TOKENIZER
+
+def extract_json(text: str) -> dict:
+    try:
+        start_idx = text.find('{')
+        end_idx = text.rfind('}') + 1
+        if start_idx != -1 and end_idx != 0:
+            return json.loads(text[start_idx:end_idx])
+    except Exception:
+        pass
+    return {"action_type": "finalize"}
+
+def _get_session(session_id: str) -> Dict[str, Any]:
+    session = _SESSIONS.get(session_id)
+    if session is None:
+        raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
+    return session
+
+def _create_env_session(task_key: str, session_id: str) -> Dict[str, Any]:
+    if task_key not in TASKS:
+        raise HTTPException(status_code=400, detail=f"Unknown task: {task_key}")
+
+    env = FlightRebookingEnv(task_data=TASKS[task_key])
+    observation = env.reset()
+    _SESSIONS[session_id] = {"task_key": task_key, "env": env, "last_action_str": None}
+
+    return {
+        "session_id": session_id,
+        "task_key": task_key,
+        "observation": observation.model_dump(mode="json"),
+    }
+
+def _step_and_format(session: Dict[str, Any], action: Action) -> Dict[str, Any]:
+    env: FlightRebookingEnv = session["env"]
+    observation, reward, done, info = env.step(action)
+
+    response: Dict[str, Any] = {
+        "observation": observation.model_dump(mode="json"),
+        "reward": reward.model_dump(mode="json"),
+        "done": done,
+        "info": info,
+    }
+
+    if done:
+        task_key = session["task_key"]
+        state = env.state()
+        response["final_score"] = grade_task(task_key, state, TASKS[task_key]["max_budget"])
+
+    return response
+
+@app.get("/")
+def root() -> Dict[str, Any]:
+    return {
+        "name": "flight-rebooking-ai",
+        "status": "ok",
+        "model_loaded": MODEL is not None and MODEL is not False,
+        "message": "Use /ui for the dashboard.",
+    }
+
+@app.get("/ui", include_in_schema=False)
+def ui_page() -> FileResponse:
+    index_file = _FRONTEND_DIR / "index.html"
+    if not index_file.exists():
+        raise HTTPException(status_code=404, detail="Frontend not found.")
+    return FileResponse(index_file)
+
+@app.post("/auto_step")
+async def auto_step(session_id: str = _DEFAULT_SESSION_ID):
+    session = _get_session(session_id)
+    env: FlightRebookingEnv = session["env"]
+    
+    model, tokenizer = load_model()
+    if model is False:
+        raise HTTPException(status_code=500, detail="AI Model failed to load.")
+    
+    obs = env.state() # Get full state for AI context
+    
+    system_prompt = "You are an airline disruption agent. Return a single JSON object with action_type, passenger_id, and flight_id."
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": f"Current State: {obs.model_dump_json()}"}
+    ]
+    
+    inputs = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)
+    
+    with torch.no_grad():
+        outputs = model.generate(inputs, max_new_tokens=64, do_sample=False)
+    
+    response_text = tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)
+    action_dict = extract_json(response_text)
+    
+    # Loop Breaker
+    action_str = json.dumps(action_dict)
+    if session.get("last_action_str") == action_str:
+        action_dict = {"action_type": "mark_no_solution", "passenger_id": action_dict.get("passenger_id", "P1")}
+    session["last_action_str"] = action_str
+
+    try:
+        action = Action(**action_dict)
+    except:
+        action = Action(action_type=ActionType.FINALIZE)
+        
+    return _step_and_format(session, action)
+
+@app.post("/reset")
+def reset_default(request: CreateSessionRequest = None) -> Dict[str, Any]:
+    if request is None: request = CreateSessionRequest()
+    return _create_env_session(task_key=request.task.lower(), session_id=_DEFAULT_SESSION_ID)
+
+@app.post("/step")
+def step_default(request: StepRequest) -> Dict[str, Any]:
+    session = _get_session(request.session_id)
+    return _step_and_format(session=session, action=request.action)
+
+@app.get("/state")
+def state_default(session_id: str = _DEFAULT_SESSION_ID) -> Dict[str, Any]:
+    session = _get_session(session_id)
+    env: FlightRebookingEnv = session["env"]
+    state = env.state()
+    return {
+        "state": state.model_dump(mode="json"),
+        "grade": grade_task(session["task_key"], state, TASKS[session["task_key"]]["max_budget"]),
+    }
+
+@app.get("/tasks")
+def list_tasks() -> Dict[str, Any]:
+    payload = []
+    for task_key, task in TASKS.items():
+        payload.append({
+            "task_key": task_key,
+            "task_id": task["task_id"],
+            "difficulty": task["difficulty"],
+            "objective": task["objective"],
+            "max_budget": task["max_budget"],
+            "passenger_count": len(task["passengers"]),
+        })
+    return {"tasks": payload}
+
+def start():
+    import uvicorn
+    uvicorn.run("app:app", host="0.0.0.0", port=7860)
+
+if __name__ == "__main__":
+    start()

environment.py

@@ -0,0 +1,602 @@
+"""
+Flight Rebooking Environment Engine
+===================================
+
+Real-world simulation of airline disruption recovery where an agent must
+rebook stranded passengers under strict business constraints.
+
+OpenEnv interface:
+  - reset() -> Observation
+  - step(Action) -> tuple[Observation, Reward, bool, dict]
+  - state() -> EnvState
+"""
+
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple
+
+from pydantic import BaseModel, Field
+
+
+class PriorityTier(str, Enum):
+    PLATINUM = "Platinum"
+    GOLD = "Gold"
+    SILVER = "Silver"
+    STANDARD = "Standard"
+
+
+class CabinClass(str, Enum):
+    BUSINESS = "Business"
+    ECONOMY = "Economy"
+
+
+class PassengerStatus(str, Enum):
+    PENDING = "pending"
+    REBOOKED = "rebooked"
+    DOWNGRADED = "downgraded"
+    HOTEL_BOOKED = "hotel_booked"
+    PARTNER_REBOOKED = "partner_rebooked"
+    NO_SOLUTION = "no_solution"
+
+
+class ActionType(str, Enum):
+    REBOOK_PASSENGER = "rebook_passenger"
+    OFFER_DOWNGRADE = "offer_downgrade"
+    BOOK_HOTEL = "book_hotel"
+    REBOOK_ON_PARTNER = "rebook_on_partner"
+    MARK_NO_SOLUTION = "mark_no_solution"
+    FINALIZE = "finalize"
+
+
+class Passenger(BaseModel):
+    """A stranded passenger awaiting re-accommodation."""
+
+    id: str
+    name: str
+    priority_tier: PriorityTier
+    original_flight: str
+    cabin_class: CabinClass
+    connection_deadline_hrs: Optional[float] = None
+    status: PassengerStatus = PassengerStatus.PENDING
+    assigned_flight: Optional[str] = None
+
+
+class Flight(BaseModel):
+    """A candidate replacement flight."""
+
+    id: str
+    destination: str
+    departure_hrs: float
+    economy_seats: int
+    business_seats: int
+    is_partner: bool = False
+
+
+class Action(BaseModel):
+    """Action model consumed by step()."""
+
+    action_type: ActionType
+    passenger_id: Optional[str] = None
+    flight_id: Optional[str] = None
+
+
+class Reward(BaseModel):
+    """Typed reward payload in the [0.0, 1.0] range."""
+
+    value: float = Field(ge=0.0, le=1.0)
+    components: Dict[str, float] = Field(default_factory=dict)
+    notes: List[str] = Field(default_factory=list)
+
+
+class Observation(BaseModel):
+    """Agent-visible state after each transition."""
+
+    pending_passengers: List[Dict[str, Any]]
+    available_flights: List[Dict[str, Any]]
+    budget_remaining: float
+    budget_spent: float
+    processed_count: int
+    total_passengers: int
+    invalid_actions: int
+    step_count: int
+
+
+class EnvState(BaseModel):
+    """Full simulator state for graders and debugging."""
+
+    passengers: List[Passenger] = Field(default_factory=list)
+    flights: List[Flight] = Field(default_factory=list)
+    budget_spent: float = 0.0
+    max_budget: float = 0.0
+    actions_taken: List[Dict[str, Any]] = Field(default_factory=list)
+    invalid_actions: int = 0
+    finalized: bool = False
+    step_count: int = 0
+
+
+ACTION_COSTS = {
+    ActionType.REBOOK_PASSENGER: 0.0,
+    ActionType.OFFER_DOWNGRADE: 500.0,
+    ActionType.BOOK_HOTEL: 250.0,
+    ActionType.REBOOK_ON_PARTNER: 800.0,
+    ActionType.MARK_NO_SOLUTION: 0.0,
+    ActionType.FINALIZE: 0.0,
+}
+
+
+PRIORITY_WEIGHTS = {
+    PriorityTier.PLATINUM: 4,
+    PriorityTier.GOLD: 3,
+    PriorityTier.SILVER: 2,
+    PriorityTier.STANDARD: 1,
+}
+
+
+OUTCOME_QUALITY = {
+    PassengerStatus.REBOOKED: 1.00,
+    PassengerStatus.PARTNER_REBOOKED: 0.85,
+    PassengerStatus.DOWNGRADED: 0.65,
+    PassengerStatus.HOTEL_BOOKED: 0.45,
+    PassengerStatus.NO_SOLUTION: 0.05,
+}
+
+
+class FlightRebookingEnv:
+    """OpenEnv-compatible flight rebooking simulator."""
+
+    def __init__(self, task_data: dict):
+        self.task_data = task_data
+        self._state: Optional[EnvState] = None
+        self._step_count = 0
+        self._max_steps = int(task_data.get("max_steps", 80))
+
+    def reset(self) -> Observation:
+        passengers = [Passenger(**p) for p in self.task_data["passengers"]]
+        flights = [Flight(**f) for f in self.task_data["flights"]]
+
+        self._state = EnvState(
+            passengers=passengers,
+            flights=flights,
+            budget_spent=0.0,
+            max_budget=self.task_data["max_budget"],
+            actions_taken=[],
+            invalid_actions=0,
+            finalized=False,
+            step_count=0,
+        )
+        self._step_count = 0
+        return self._get_observation()
+
+    def state(self) -> EnvState:
+        if self._state is None:
+            raise RuntimeError("Environment is not initialized. Call reset() first.")
+        return self._state
+
+    def step(self, action: Action) -> Tuple[Observation, Reward, bool, Dict[str, Any]]:
+        if self._state is None:
+            raise RuntimeError("Environment is not initialized. Call reset() first.")
+
+        self._step_count += 1
+        self._state.step_count = self._step_count
+        info: Dict[str, Any] = {}
+
+        if self._state.finalized:
+            reward = Reward(value=0.01, components={"terminal": 1.0}, notes=["episode_already_finalized"])
+            return self._get_observation(), reward, True, {"warning": "Episode already finalized."}
+
+        if self._step_count > self._max_steps:
+            self._state.finalized = True
+            reward = Reward(
+                value=0.01,
+                components={
+                    "progress": self._completion_ratio(),
+                    "budget_efficiency": self._budget_efficiency(),
+                    "max_step_exceeded": 1.0,
+                },
+                notes=["forced_finalize_max_steps"],
+            )
+            self._record_action(action, reward, success=False, done=True, info={"warning": "Max steps reached."})
+            return self._get_observation(), reward, True, {"warning": "Max steps reached, forcing finalize."}
+
+        if action.action_type == ActionType.FINALIZE:
+            reward = self._build_finalize_reward()
+            self._state.finalized = True
+            unresolved = [p.id for p in self._state.passengers if p.status == PassengerStatus.PENDING]
+            if unresolved:
+                info["unresolved_passengers"] = unresolved
+            self._record_action(action, reward, success=(len(unresolved) == 0), done=True, info=info)
+            return self._get_observation(), reward, True, info
+
+        passenger = self._find_passenger(action.passenger_id)
+        if passenger is None:
+            reward = self._invalid_reward("passenger_not_found")
+            info["error"] = f"Passenger not found: {action.passenger_id}"
+            self._record_action(action, reward, success=False, done=False, info=info)
+            return self._get_observation(), reward, False, info
+
+        if passenger.status != PassengerStatus.PENDING:
+            reward = self._invalid_reward("passenger_already_processed")
+            info["error"] = f"Passenger {action.passenger_id} already processed ({passenger.status.value})."
+            self._record_action(action, reward, success=False, done=False, info=info)
+            return self._get_observation(), reward, False, info
+
+        priority_inversion = self._has_higher_priority_pending(passenger)
+
+        handler = {
+            ActionType.REBOOK_PASSENGER: self._handle_rebook,
+            ActionType.OFFER_DOWNGRADE: self._handle_downgrade,
+            ActionType.BOOK_HOTEL: self._handle_hotel,
+            ActionType.REBOOK_ON_PARTNER: self._handle_partner,
+            ActionType.MARK_NO_SOLUTION: self._handle_no_solution,
+        }[action.action_type]
+
+        success, action_info = handler(passenger, action)
+        info.update(action_info)
+
+        if not success:
+            reward = self._invalid_reward(info.get("error", "invalid_action"))
+            self._record_action(action, reward, success=False, done=False, info=info)
+            return self._get_observation(), reward, False, info
+
+        repeat_penalty = self._repeat_failure_penalty(action)
+        reward = self._build_resolution_reward(
+            passenger=passenger,
+            flight=self._find_flight(passenger.assigned_flight),
+            action_cost=ACTION_COSTS[action.action_type],
+            priority_inversion=priority_inversion,
+            repeat_penalty=repeat_penalty,
+        )
+
+        done = all(p.status != PassengerStatus.PENDING for p in self._state.passengers)
+        if done:
+            self._state.finalized = True
+            reward = self._add_terminal_bonus(reward)
+            info["auto_finalized"] = True
+
+        self._record_action(action, reward, success=True, done=done, info=info)
+        return self._get_observation(), reward, done, info
+
+    def _handle_rebook(self, passenger: Passenger, action: Action) -> Tuple[bool, Dict[str, Any]]:
+        flight = self._find_flight(action.flight_id)
+        if flight is None:
+            return False, {"error": f"Flight not found: {action.flight_id}"}
+
+        if flight.is_partner:
+            return False, {"error": "Use rebook_on_partner for partner flights."}
+
+        ok, msg = self._consume_seat(flight, passenger.cabin_class)
+        if not ok:
+            return False, {"error": msg}
+
+        passenger.status = PassengerStatus.REBOOKED
+        passenger.assigned_flight = flight.id
+        return True, {"resolved_status": passenger.status.value}
+
+    def _handle_downgrade(self, passenger: Passenger, action: Action) -> Tuple[bool, Dict[str, Any]]:
+        if passenger.cabin_class != CabinClass.BUSINESS:
+            return False, {"error": "Can only downgrade Business passengers."}
+
+        cost = ACTION_COSTS[ActionType.OFFER_DOWNGRADE]
+        if not self._spend(cost):
+            return False, {"error": f"Insufficient budget. Need ${cost:.0f}, have ${self._budget_remaining():.0f}."}
+
+        flight = self._find_flight(action.flight_id)
+        if flight is None:
+            self._refund(cost)
+            return False, {"error": f"Flight not found: {action.flight_id}"}
+
+        ok, msg = self._consume_seat(flight, CabinClass.ECONOMY)
+        if not ok:
+            self._refund(cost)
+            return False, {"error": msg}
+
+        passenger.status = PassengerStatus.DOWNGRADED
+        passenger.assigned_flight = flight.id
+        return True, {"resolved_status": passenger.status.value}
+
+    def _handle_hotel(self, passenger: Passenger, action: Action) -> Tuple[bool, Dict[str, Any]]:
+        cost = ACTION_COSTS[ActionType.BOOK_HOTEL]
+        if not self._spend(cost):
+            return False, {"error": f"Insufficient budget. Need ${cost:.0f}, have ${self._budget_remaining():.0f}."}
+
+        passenger.status = PassengerStatus.HOTEL_BOOKED
+        passenger.assigned_flight = None
+        return True, {"resolved_status": passenger.status.value}
+
+    def _handle_partner(self, passenger: Passenger, action: Action) -> Tuple[bool, Dict[str, Any]]:
+        cost = ACTION_COSTS[ActionType.REBOOK_ON_PARTNER]
+        if not self._spend(cost):
+            return False, {"error": f"Insufficient budget. Need ${cost:.0f}, have ${self._budget_remaining():.0f}."}
+
+        flight = self._find_flight(action.flight_id)
+        if flight is None:
+            self._refund(cost)
+            return False, {"error": f"Flight not found: {action.flight_id}"}
+
+        if not flight.is_partner:
+            self._refund(cost)
+            return False, {"error": f"Flight {action.flight_id} is not a partner flight."}
+
+        ok, msg = self._consume_seat(flight, passenger.cabin_class)
+        if not ok:
+            self._refund(cost)
+            return False, {"error": msg}
+
+        passenger.status = PassengerStatus.PARTNER_REBOOKED
+        passenger.assigned_flight = flight.id
+        return True, {"resolved_status": passenger.status.value}
+
+    def _handle_no_solution(self, passenger: Passenger, action: Action) -> Tuple[bool, Dict[str, Any]]:
+        passenger.status = PassengerStatus.NO_SOLUTION
+        passenger.assigned_flight = None
+        return True, {"resolved_status": passenger.status.value}
+
+    def _invalid_reward(self, reason: str) -> Reward:
+        self._state.invalid_actions += 1
+        penalty = min(0.08 * self._state.invalid_actions, 0.5)
+        return Reward(
+            value=max(0.01, 0.05 - penalty),
+            components={
+                "progress": self._completion_ratio(),
+                "budget_efficiency": self._budget_efficiency(),
+                "invalid_action_penalty": penalty,
+            },
+            notes=[reason, "invalid_action"],
+        )
+
+    def _build_resolution_reward(
+        self,
+        passenger: Passenger,
+        flight: Optional[Flight],
+        action_cost: float,
+        priority_inversion: bool,
+        repeat_penalty: float,
+    ) -> Reward:
+        progress = self._completion_ratio()
+        outcome_quality = OUTCOME_QUALITY.get(passenger.status, 0.0)
+        priority_score = PRIORITY_WEIGHTS[passenger.priority_tier] / 4.0
+        deadline_score = self._deadline_score(passenger, flight)
+        budget_efficiency = self._budget_efficiency()
+
+        penalty = 0.0
+        notes: List[str] = []
+
+        if priority_inversion:
+            penalty += 0.15
+            notes.append("priority_inversion")
+
+        if repeat_penalty > 0:
+            penalty += repeat_penalty
+            notes.append("repeated_failed_action_pattern")
+
+        if passenger.status == PassengerStatus.NO_SOLUTION:
+            penalty += 0.2
+            notes.append("no_solution_penalty")
+
+        if action_cost > 0:
+            # Costly actions are valid but receive a mild regularization penalty.
+            penalty += min(action_cost / max(self._state.max_budget, 1.0), 0.15)
+
+        base = (
+            (0.30 * outcome_quality)
+            + (0.25 * progress)
+            + (0.15 * priority_score)
+            + (0.15 * deadline_score)
+            + (0.15 * budget_efficiency)
+        )
+
+        value = self._clamp(base - penalty)
+        return Reward(
+            value=value,
+            components={
+                "progress": progress,
+                "outcome_quality": outcome_quality,
+                "priority_score": priority_score,
+                "deadline_score": deadline_score,
+                "budget_efficiency": budget_efficiency,
+                "penalty": penalty,
+            },
+            notes=notes,
+        )
+
+    def _build_finalize_reward(self) -> Reward:
+        pending_count = sum(1 for p in self._state.passengers if p.status == PassengerStatus.PENDING)
+        total = max(len(self._state.passengers), 1)
+        completion = self._completion_ratio()
+        budget_efficiency = self._budget_efficiency()
+
+        if pending_count == 0:
+            value = self._clamp((0.85 * completion) + (0.15 * budget_efficiency))
+            notes = ["clean_finalize"]
+        else:
+            unresolved_penalty = pending_count / total
+            value = self._clamp(0.20 * completion - 0.30 * unresolved_penalty)
+            notes = ["early_finalize_penalty"]
+
+        return Reward(
+            value=value,
+            components={
+                "completion": completion,
+                "budget_efficiency": budget_efficiency,
+                "pending_ratio": pending_count / total,
+            },
+            notes=notes,
+        )
+
+    def _add_terminal_bonus(self, reward: Reward) -> Reward:
+        bonus = 0.1 * max(0.0, 1.0 - (self._state.invalid_actions * 0.05))
+        merged = dict(reward.components)
+        merged["terminal_bonus"] = bonus
+        return Reward(
+            value=self._clamp(reward.value + bonus),
+            components=merged,
+            notes=reward.notes + ["all_passengers_processed"],
+        )
+
+    def _deadline_score(self, passenger: Passenger, flight: Optional[Flight]) -> float:
+        if passenger.connection_deadline_hrs is None:
+            return 1.0
+
+        if flight is None:
+            return 0.0
+
+        if flight.departure_hrs <= passenger.connection_deadline_hrs:
+            return 1.0
+
+        return 0.2
+
+    def _has_higher_priority_pending(self, passenger: Passenger) -> bool:
+        current_weight = PRIORITY_WEIGHTS[passenger.priority_tier]
+        for other in self._state.passengers:
+            if other.id == passenger.id or other.status != PassengerStatus.PENDING:
+                continue
+
+            other_weight = PRIORITY_WEIGHTS[other.priority_tier]
+            if other_weight > current_weight:
+                return True
+
+            if (
+                other_weight == current_weight
+                and other.connection_deadline_hrs is not None
+                and passenger.connection_deadline_hrs is not None
+                and other.connection_deadline_hrs < passenger.connection_deadline_hrs
+            ):
+                return True
+
+            if (
+                other_weight == current_weight
+                and other.connection_deadline_hrs is not None
+                and passenger.connection_deadline_hrs is None
+            ):
+                return True
+
+        return False
+
+    def _repeat_failure_penalty(self, action: Action) -> float:
+        if len(self._state.actions_taken) < 2:
+            return 0.0
+
+        signature = self._signature(action)
+        recent = self._state.actions_taken[-2:]
+        repeated_failures = all(
+            (not item.get("success", True)) and tuple(item.get("signature", ())) == signature
+            for item in recent
+        )
+        return 0.1 if repeated_failures else 0.0
+
+    def _completion_ratio(self) -> float:
+        total = max(len(self._state.passengers), 1)
+        processed = sum(1 for p in self._state.passengers if p.status != PassengerStatus.PENDING)
+        return processed / total
+
+    def _budget_efficiency(self) -> float:
+        if self._state.max_budget <= 0:
+            return 1.0
+        return self._clamp(1.0 - (self._state.budget_spent / self._state.max_budget))
+
+    def _spend(self, cost: float) -> bool:
+        if (self._state.budget_spent + cost) > self._state.max_budget:
+            return False
+        self._state.budget_spent += cost
+        return True
+
+    def _refund(self, cost: float) -> None:
+        self._state.budget_spent = max(0.0, self._state.budget_spent - cost)
+
+    def _find_passenger(self, passenger_id: Optional[str]) -> Optional[Passenger]:
+        if passenger_id is None:
+            return None
+        for passenger in self._state.passengers:
+            if passenger.id == passenger_id:
+                return passenger
+        return None
+
+    def _find_flight(self, flight_id: Optional[str]) -> Optional[Flight]:
+        if flight_id is None:
+            return None
+        for flight in self._state.flights:
+            if flight.id == flight_id:
+                return flight
+        return None
+
+    def _consume_seat(self, flight: Flight, cabin: CabinClass) -> Tuple[bool, str]:
+        if cabin == CabinClass.BUSINESS:
+            if flight.business_seats <= 0:
+                return False, f"No Business seats on {flight.id}."
+            flight.business_seats -= 1
+            return True, ""
+
+        if flight.economy_seats <= 0:
+            return False, f"No Economy seats on {flight.id}."
+        flight.economy_seats -= 1
+        return True, ""
+
+    def _budget_remaining(self) -> float:
+        return self._state.max_budget - self._state.budget_spent
+
+    def _signature(self, action: Action) -> Tuple[str, Optional[str], Optional[str]]:
+        return action.action_type.value, action.passenger_id, action.flight_id
+
+    def _record_action(self, action: Action, reward: Reward, success: bool, done: bool, info: Dict[str, Any]) -> None:
+        self._state.actions_taken.append(
+            {
+                "step": self._step_count,
+                "signature": self._signature(action),
+                "action": action.model_dump(mode="json"),
+                "reward": reward.model_dump(mode="json"),
+                "success": success,
+                "done": done,
+                "info": info,
+            }
+        )
+
+    def _clamp(self, value: float) -> float:
+        return max(0.01, min(0.99, value))
+
+    def _get_observation(self) -> Observation:
+        pending_passengers: List[Dict[str, Any]] = []
+        for passenger in self._state.passengers:
+            if passenger.status != PassengerStatus.PENDING:
+                continue
+            pending_passengers.append(
+                {
+                    "id": passenger.id,
+                    "name": passenger.name,
+                    "priority_tier": passenger.priority_tier.value,
+                    "original_flight": passenger.original_flight,
+                    "cabin_class": passenger.cabin_class.value,
+                    "connection_deadline_hrs": passenger.connection_deadline_hrs,
+                }
+            )
+
+        pending_passengers.sort(
+            key=lambda p: (
+                -PRIORITY_WEIGHTS[PriorityTier(p["priority_tier"])],
+                p["connection_deadline_hrs"] if p["connection_deadline_hrs"] is not None else 1e9,
+            )
+        )
+
+        available_flights: List[Dict[str, Any]] = []
+        for flight in self._state.flights:
+            available_flights.append(
+                {
+                    "id": flight.id,
+                    "destination": flight.destination,
+                    "departure_hrs": flight.departure_hrs,
+                    "economy_seats": flight.economy_seats,
+                    "business_seats": flight.business_seats,
+                    "is_partner": flight.is_partner,
+                }
+            )
+
+        processed = sum(1 for p in self._state.passengers if p.status != PassengerStatus.PENDING)
+
+        return Observation(
+            pending_passengers=pending_passengers,
+            available_flights=available_flights,
+            budget_remaining=self._budget_remaining(),
+            budget_spent=self._state.budget_spent,
+            processed_count=processed,
+            total_passengers=len(self._state.passengers),
+            invalid_actions=self._state.invalid_actions,
+            step_count=self._step_count,
+        )

frontend/app.js

@@ -0,0 +1,224 @@
+const state = {
+  tasks: [],
+  selectedTask: "easy",
+  sessionId: "default",
+  observation: null,
+  done: false,
+  grade: null,
+  logs: [],
+  latest: null,
+  showRawLatest: false,
+};
+
+const refs = {
+  taskSelect: document.getElementById("taskSelect"),
+  resetBtn: document.getElementById("resetBtn"),
+  autoBtn: document.getElementById("autoBtn"),
+  aiBtn: document.getElementById("aiBtn"),
+  finalizeBtn: document.getElementById("finalizeBtn"),
+  suggestBtn: document.getElementById("suggestBtn"),
+  runStepBtn: document.getElementById("runStepBtn"),
+  clearLogBtn: document.getElementById("clearLogBtn"),
+  actionForm: document.getElementById("actionForm"),
+  actionType: document.getElementById("actionType"),
+  passengerId: document.getElementById("passengerId"),
+  flightId: document.getElementById("flightId"),
+  sessionBadge: document.getElementById("sessionBadge"),
+  phaseBadge: document.getElementById("phaseBadge"),
+  scoreBadge: document.getElementById("scoreBadge"),
+  taskMeta: document.getElementById("taskMeta"),
+  budgetRemaining: document.getElementById("budgetRemaining"),
+  budgetSpent: document.getElementById("budgetSpent"),
+  progressValue: document.getElementById("progressValue"),
+  invalidValue: document.getElementById("invalidValue"),
+  stepCountBadge: document.getElementById("stepCountBadge"),
+  pendingList: document.getElementById("pendingList"),
+  flightsList: document.getElementById("flightsList"),
+  latestResult: document.getElementById("latestResult"),
+  latestRaw: document.getElementById("latestRaw"),
+  toggleRawBtn: document.getElementById("toggleRawBtn"),
+  logList: document.getElementById("logList"),
+};
+
+function money(value) {
+  return `$${Number(value || 0).toFixed(2)}`;
+}
+
+function safeJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+function latestRow(label, value) {
+  return `
+    <div class="latest-row">
+      <span class="latest-label">${escapeHtml(label)}</span>
+      <span class="latest-value">${escapeHtml(value)}</span>
+    </div>
+  `;
+}
+
+function buildLatestSummary() {
+  const data = state.latest;
+  if (!data) return '<div class="latest-empty">No actions yet.</div>';
+  if (data.error) return `<div class="latest-status latest-status-error">Error</div><div class="latest-note">${escapeHtml(data.error)}</div>`;
+  
+  if (data.event === "reset") {
+    return `<div class="latest-status latest-status-reset">Session reset</div>${latestRow("Task", data.task)}${latestRow("Session", data.session_id)}`;
+  }
+
+  const summary = [];
+  summary.push(`<div class="latest-status ${data.done ? "latest-status-done" : "latest-status-active"}">${data.done ? "Complete" : "Step Applied"}</div>`);
+  
+  const obs = data.observation || {};
+  summary.push(latestRow("Reward", Number(data.reward?.value || 0).toFixed(4)));
+  summary.push(latestRow("Budget Spent", money(obs.budget_spent)));
+  summary.push(latestRow("Remaining", money(obs.budget_remaining)));
+  
+  if (data.final_score !== undefined) {
+    summary.push(latestRow("Final Score", Number(data.final_score).toFixed(4)));
+  }
+
+  return summary.join("");
+}
+
+async function api(path, options = {}) {
+  const response = await fetch(path, {
+    headers: { "Content-Type": "application/json" },
+    ...options,
+  });
+  const payload = await response.json();
+  if (!response.ok) throw new Error(payload.detail || "API Error");
+  return payload;
+}
+
+function renderAll() {
+  const obs = state.observation;
+  if (!obs) return;
+
+  refs.sessionBadge.textContent = `Session: ${state.sessionId}`;
+  refs.phaseBadge.textContent = `State: ${state.done ? "Done" : "Active"}`;
+  refs.scoreBadge.textContent = `Grade: ${state.grade == null ? "-" : Number(state.grade).toFixed(4)}`;
+  
+  refs.budgetRemaining.textContent = money(obs.budget_remaining);
+  refs.budgetSpent.textContent = money(obs.budget_spent);
+  refs.progressValue.textContent = `${obs.processed_count}/${obs.total_passengers}`;
+  refs.invalidValue.textContent = obs.invalid_actions || 0;
+  refs.stepCountBadge.textContent = `step ${obs.step_count || 0}`;
+
+  // Render Lists
+  refs.pendingList.innerHTML = (obs.pending_passengers || []).map(p => `
+    <div class="card card-passenger">
+      <strong>${p.id}</strong> - ${p.priority_tier}<br>
+      <small>${p.cabin_class} | ${p.original_flight}</small>
+    </div>
+  `).join("");
+
+  refs.flightsList.innerHTML = (obs.available_flights || []).map(f => `
+    <div class="card card-flight">
+      <strong>${f.id}</strong> ${f.is_partner ? "(Partner)" : ""}<br>
+      <small>T+${f.departure_hrs}h | E:${f.economy_seats} B:${f.business_seats}</small>
+    </div>
+  `).join("");
+
+  refs.latestResult.innerHTML = buildLatestSummary();
+  
+  // Update Dropdowns
+  const passOpts = obs.pending_passengers.map(p => `<option value="${p.id}">${p.id}</option>`).join("");
+  refs.passengerId.innerHTML = '<option value="">Select Passenger</option>' + passOpts;
+
+  const flightOpts = obs.available_flights.map(f => `<option value="${f.id}">${f.id}</option>`).join("");
+  refs.flightId.innerHTML = '<option value="">Select Flight</option>' + flightOpts;
+}
+
+async function resetSession() {
+  const result = await api("/reset", {
+    method: "POST",
+    body: JSON.stringify({ task: refs.taskSelect.value }),
+  });
+  state.sessionId = result.session_id;
+  state.observation = result.observation;
+  state.done = false;
+  state.grade = null;
+  state.logs = [];
+  state.latest = { event: "reset", task: result.task_key, session_id: result.session_id };
+  renderAll();
+}
+
+async function runStep(action) {
+  const result = await api("/step", {
+    method: "POST",
+    body: JSON.stringify({ session_id: state.sessionId, action }),
+  });
+  processResult(result, action);
+}
+
+async function runAIStep(recursive = false) {
+  if (state.done) return;
+  refs.aiBtn.disabled = true;
+  refs.aiBtn.textContent = "AI Thinking...";
+  try {
+    const result = await api(`/auto_step?session_id=${encodeURIComponent(state.sessionId)}`, { method: "POST" });
+    processResult(result, { action_type: "AI_INFERENCE" });
+    if (recursive && !state.done) {
+      setTimeout(() => runAIStep(true), 500);
+    }
+  } catch (err) {
+    showError(err);
+  } finally {
+    if (!recursive || state.done) {
+      refs.aiBtn.disabled = false;
+      refs.aiBtn.textContent = "AI Auto-Play";
+    }
+  }
+}
+
+function processResult(result, action) {
+  state.observation = result.observation;
+  state.done = !!result.done;
+  state.latest = result;
+  state.logs.push({ action, reward: result.reward?.value || 0 });
+  if (result.final_score !== undefined) state.grade = result.final_score;
+  renderAll();
+}
+
+function showError(err) {
+  state.latest = { error: err.message };
+  renderAll();
+}
+
+async function loadTasks() {
+  const result = await api("/tasks");
+  state.tasks = result.tasks;
+  refs.taskSelect.innerHTML = state.tasks.map(t => `<option value="${t.task_key}">${t.task_key.toUpperCase()}</option>`).join("");
+}
+
+function bindEvents() {
+  refs.resetBtn.onclick = resetSession;
+  refs.aiBtn.onclick = () => runAIStep(true);
+  refs.runStepBtn.onclick = (e) => {
+    e.preventDefault();
+    const action = {
+      action_type: refs.actionType.value,
+      passenger_id: refs.passengerId.value,
+      flight_id: refs.flightId.value
+    };
+    runStep(action);
+  };
+}
+
+async function init() {
+  bindEvents();
+  await loadTasks();
+  await resetSession();
+}
+
+init();

frontend/index.html

@@ -0,0 +1,141 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Flight Rebooking Control Tower</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Bricolage+Grotesque:wght@400;600;700;800&family=Space+Grotesk:wght@400;500;700&display=swap"
+      rel="stylesheet"
+    />
+    <link rel="stylesheet" href="/ui/static/style.css" />
+  </head>
+  <body>
+    <div class="shape shape-a" aria-hidden="true"></div>
+    <div class="shape shape-b" aria-hidden="true"></div>
+    <div class="shape shape-c" aria-hidden="true"></div>
+
+    <header class="hero">
+      <div class="hero-title-wrap">
+        <p class="eyebrow">Operations Console</p>
+        <h1>Flight Rebooking Control Tower</h1>
+        <p class="subtitle">
+          Run realistic disruption scenarios, inspect passenger queues, and steer the agent
+          action-by-action with live rewards.
+        </p>
+      </div>
+      <div class="hero-badges">
+        <span id="sessionBadge" class="badge">Session: -</span>
+        <span id="phaseBadge" class="badge badge-accent">State: idle</span>
+        <span id="scoreBadge" class="badge badge-score">Grade: -</span>
+      </div>
+    </header>
+
+    <main class="grid">
+      <section class="panel mission">
+        <h2>Mission Setup</h2>
+        <label for="taskSelect">Task</label>
+        <select id="taskSelect"></select>
+
+        <div class="button-row">
+          <button id="resetBtn" class="btn btn-primary">Reset Session</button>
+          <button id="autoBtn" class="btn btn-secondary">Heuristic Step</button>
+          <button id="aiBtn" class="btn btn-accent">AI Auto-Play</button>
+          <button id="finalizeBtn" class="btn btn-danger">Finalize</button>
+        </div>
+
+        <div id="taskMeta" class="task-meta"></div>
+
+        <div class="metrics">
+          <article class="metric">
+            <p class="metric-label">Budget Remaining</p>
+            <p id="budgetRemaining" class="metric-value">-</p>
+          </article>
+          <article class="metric">
+            <p class="metric-label">Budget Spent</p>
+            <p id="budgetSpent" class="metric-value">-</p>
+          </article>
+          <article class="metric">
+            <p class="metric-label">Progress</p>
+            <p id="progressValue" class="metric-value">-</p>
+          </article>
+          <article class="metric">
+            <p class="metric-label">Invalid Actions</p>
+            <p id="invalidValue" class="metric-value">-</p>
+          </article>
+        </div>
+      </section>
+
+      <section class="panel observation">
+        <div class="panel-head">
+          <h2>Live Observation</h2>
+          <span id="stepCountBadge" class="chip">step 0</span>
+        </div>
+
+        <div class="split">
+          <section class="observation-group observation-passengers">
+            <div class="group-head">
+              <h3><span class="group-dot" aria-hidden="true"></span>Pending Passengers</h3>
+              <span class="group-tag">Queue</span>
+            </div>
+            <div id="pendingList" class="scroll-list list-passengers"></div>
+          </section>
+          <section class="observation-group observation-flights">
+            <div class="group-head">
+              <h3><span class="group-dot" aria-hidden="true"></span>Available Flights</h3>
+              <span class="group-tag">Inventory</span>
+            </div>
+            <div id="flightsList" class="scroll-list list-flights"></div>
+          </section>
+        </div>
+      </section>
+
+      <section class="panel action-console">
+        <h2>Action Console</h2>
+        <form id="actionForm">
+          <label for="actionType">Action Type</label>
+          <select id="actionType">
+            <option value="rebook_passenger">rebook_passenger</option>
+            <option value="offer_downgrade">offer_downgrade</option>
+            <option value="book_hotel">book_hotel</option>
+            <option value="rebook_on_partner">rebook_on_partner</option>
+            <option value="mark_no_solution">mark_no_solution</option>
+            <option value="finalize">finalize</option>
+          </select>
+
+          <label for="passengerId">Passenger</label>
+          <select id="passengerId"></select>
+
+          <label for="flightId">Flight</label>
+          <select id="flightId"></select>
+
+          <div class="button-row stacked">
+            <button id="suggestBtn" type="button" class="btn btn-ghost">Use Suggestion</button>
+            <button id="runStepBtn" type="submit" class="btn btn-primary">Run Step</button>
+          </div>
+        </form>
+
+        <section class="result-box">
+          <div class="result-head">
+            <h3>Latest Step</h3>
+            <button id="toggleRawBtn" type="button" class="btn btn-ghost compact">Show Raw JSON</button>
+          </div>
+          <div id="latestResult" class="latest-summary">No actions yet.</div>
+          <pre id="latestRaw" class="latest-raw hidden"></pre>
+        </section>
+      </section>
+    </main>
+
+    <section class="panel timeline">
+      <div class="panel-head">
+        <h2>Trajectory Log</h2>
+        <button id="clearLogBtn" class="btn btn-ghost compact">Clear</button>
+      </div>
+      <div id="logList" class="log-list"></div>
+    </section>
+
+    <script src="/ui/static/app.js"></script>
+  </body>
+</html>

frontend/style.css

@@ -0,0 +1,686 @@
+:root {
+  --bg-1: #081a1d;
+  --bg-2: #0f2c30;
+  --panel: rgba(10, 23, 26, 0.76);
+  --panel-stroke: rgba(180, 223, 210, 0.2);
+  --text: #f6f4ee;
+  --muted: #b5d2ca;
+  --accent-hot: #ff6a3d;
+  --accent-cool: #2ce0bf;
+  --accent-gold: #f5c85b;
+  --passenger-accent: #f5c85b;
+  --flight-accent: #73d8ff;
+  --danger: #ff4f4f;
+  --shadow: 0 22px 55px rgba(0, 0, 0, 0.36);
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  margin: 0;
+  padding: 0;
+  min-height: 100%;
+}
+
+body {
+  color: var(--text);
+  font-family: "Space Grotesk", "Trebuchet MS", sans-serif;
+  line-height: 1.45;
+  background:
+    radial-gradient(circle at 14% 16%, #215157 0%, transparent 31%),
+    radial-gradient(circle at 88% 0%, #612a12 0%, transparent 27%),
+    linear-gradient(155deg, var(--bg-1), var(--bg-2));
+  padding: 1.4rem;
+  position: relative;
+  overflow-x: hidden;
+}
+
+.shape {
+  position: fixed;
+  pointer-events: none;
+  z-index: 0;
+  border-radius: 999px;
+  filter: blur(36px);
+  opacity: 0.42;
+}
+
+.shape-a {
+  width: 220px;
+  height: 220px;
+  left: -60px;
+  top: 22%;
+  background: #2ad8b6;
+}
+
+.shape-b {
+  width: 280px;
+  height: 280px;
+  right: -120px;
+  top: -80px;
+  background: #ff7348;
+}
+
+.shape-c {
+  width: 190px;
+  height: 190px;
+  right: 30%;
+  bottom: -80px;
+  background: #ebb94e;
+}
+
+.hero,
+.grid,
+.timeline {
+  position: relative;
+  z-index: 1;
+}
+
+.hero {
+  display: flex;
+  justify-content: space-between;
+  gap: 1.25rem;
+  align-items: flex-start;
+  margin-bottom: 1.2rem;
+  animation: reveal-up 500ms ease-out both;
+}
+
+.hero-title-wrap {
+  max-width: 760px;
+}
+
+.eyebrow {
+  margin: 0;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--accent-cool);
+  font-weight: 700;
+}
+
+h1,
+h2,
+h3 {
+  font-family: "Bricolage Grotesque", "Segoe UI", sans-serif;
+  margin: 0;
+  line-height: 1.08;
+}
+
+h1 {
+  font-size: clamp(1.75rem, 3.3vw, 2.8rem);
+  margin-top: 0.25rem;
+}
+
+.subtitle {
+  margin: 0.6rem 0 0;
+  color: var(--muted);
+  max-width: 60ch;
+  line-height: 1.4;
+}
+
+.hero-badges {
+  display: flex;
+  gap: 0.65rem;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
+.badge {
+  background: rgba(14, 39, 44, 0.82);
+  border: 1px solid var(--panel-stroke);
+  border-radius: 999px;
+  padding: 0.42rem 0.78rem;
+  font-size: 0.85rem;
+}
+
+.badge-accent {
+  border-color: rgba(44, 224, 191, 0.7);
+}
+
+.badge-score {
+  border-color: rgba(245, 200, 91, 0.65);
+}
+
+.grid {
+  display: grid;
+  grid-template-columns: 1fr 1.5fr 1fr;
+  gap: 1.2rem;
+  margin-bottom: 1.2rem;
+}
+
+.panel {
+  border: 1px solid var(--panel-stroke);
+  border-radius: 1rem;
+  background: var(--panel);
+  backdrop-filter: blur(8px);
+  box-shadow: var(--shadow);
+  padding: 1.15rem;
+}
+
+.panel h2 {
+  font-size: 1.22rem;
+  margin-bottom: 0.9rem;
+}
+
+label {
+  display: block;
+  font-size: 0.84rem;
+  color: var(--muted);
+  margin-top: 0.62rem;
+}
+
+select,
+button {
+  font: inherit;
+}
+
+select {
+  width: 100%;
+  border-radius: 0.65rem;
+  border: 1px solid rgba(170, 225, 210, 0.34);
+  background: rgba(4, 18, 21, 0.85);
+  color: var(--text);
+  padding: 0.58rem 0.68rem;
+  margin-top: 0.3rem;
+}
+
+select:focus,
+button:focus {
+  outline: 2px solid rgba(44, 224, 191, 0.55);
+  outline-offset: 1px;
+}
+
+.button-row {
+  display: flex;
+  gap: 0.6rem;
+  margin-top: 0.82rem;
+  flex-wrap: wrap;
+}
+
+.button-row.stacked {
+  margin-top: 0.9rem;
+}
+
+.btn {
+  border: none;
+  border-radius: 0.65rem;
+  padding: 0.6rem 0.84rem;
+  cursor: pointer;
+  font-weight: 700;
+  transition: transform 120ms ease, filter 120ms ease;
+}
+
+.btn:hover {
+  transform: translateY(-1px);
+  filter: brightness(1.08);
+}
+
+.btn:disabled {
+  opacity: 0.45;
+  cursor: not-allowed;
+  transform: none;
+}
+
+.btn-primary {
+  background: linear-gradient(135deg, #ff6a3d, #ff914f);
+  color: #1c0f05;
+}
+
+.btn-secondary {
+  background: linear-gradient(135deg, #26ccad, #58f2ca);
+  color: #072523;
+}
+
+.btn-danger {
+  background: linear-gradient(135deg, #ea3f3f, #ff6d55);
+  color: #2a0404;
+}
+
+.btn-ghost {
+  background: rgba(14, 35, 39, 0.84);
+  color: var(--text);
+  border: 1px solid rgba(167, 220, 207, 0.3);
+}
+
+.btn.compact {
+  padding: 0.32rem 0.55rem;
+}
+
+.task-meta {
+  margin-top: 0.85rem;
+  color: var(--muted);
+  line-height: 1.5;
+  min-height: 3rem;
+}
+
+.metrics {
+  margin-top: 0.85rem;
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 0.62rem;
+}
+
+.metric {
+  background: rgba(9, 28, 33, 0.8);
+  border: 1px solid rgba(164, 219, 205, 0.26);
+  border-radius: 0.72rem;
+  padding: 0.62rem;
+}
+
+.metric-label {
+  margin: 0;
+  color: var(--muted);
+  font-size: 0.76rem;
+}
+
+.metric-value {
+  margin: 0.24rem 0 0;
+  font-size: 1.05rem;
+  font-weight: 700;
+}
+
+.panel-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 0.82rem;
+}
+
+.chip {
+  font-size: 0.78rem;
+  padding: 0.24rem 0.52rem;
+  border-radius: 999px;
+  background: rgba(15, 43, 50, 0.84);
+  border: 1px solid rgba(167, 218, 204, 0.28);
+}
+
+.split {
+  display: grid;
+  grid-template-columns: minmax(0, 1.1fr) minmax(0, 1fr);
+  gap: 0.95rem;
+}
+
+.observation-group {
+  border: 1px solid rgba(157, 214, 200, 0.26);
+  border-radius: 0.9rem;
+  padding: 0.7rem;
+  background: rgba(5, 20, 24, 0.5);
+}
+
+.group-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 0.55rem;
+  margin-bottom: 0.55rem;
+}
+
+.group-head h3 {
+  margin: 0;
+  display: flex;
+  align-items: center;
+  gap: 0.45rem;
+}
+
+.group-dot {
+  width: 0.55rem;
+  height: 0.55rem;
+  border-radius: 999px;
+  display: inline-block;
+  box-shadow: 0 0 0 4px rgba(255, 255, 255, 0.04);
+}
+
+.group-tag {
+  font-size: 0.7rem;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  border-radius: 999px;
+  padding: 0.2rem 0.46rem;
+  border: 1px solid transparent;
+}
+
+.observation-passengers {
+  border-color: rgba(245, 200, 91, 0.34);
+  background: linear-gradient(160deg, rgba(245, 200, 91, 0.08), rgba(5, 20, 24, 0.56));
+}
+
+.observation-passengers .group-dot {
+  background: var(--passenger-accent);
+}
+
+.observation-passengers .group-tag {
+  color: #ffe1a6;
+  border-color: rgba(245, 200, 91, 0.55);
+  background: rgba(100, 73, 17, 0.34);
+}
+
+.observation-flights {
+  border-color: rgba(115, 216, 255, 0.34);
+  background: linear-gradient(160deg, rgba(115, 216, 255, 0.08), rgba(5, 20, 24, 0.56));
+}
+
+.observation-flights .group-dot {
+  background: var(--flight-accent);
+}
+
+.observation-flights .group-tag {
+  color: #bdeaff;
+  border-color: rgba(115, 216, 255, 0.56);
+  background: rgba(12, 59, 77, 0.35);
+}
+
+.list-passengers {
+  border-top: 1px dashed rgba(245, 200, 91, 0.3);
+  padding-top: 0.52rem;
+}
+
+.list-flights {
+  border-top: 1px dashed rgba(115, 216, 255, 0.3);
+  padding-top: 0.52rem;
+}
+
+.split h3 {
+  font-size: 0.98rem;
+  margin-bottom: 0.58rem;
+  line-height: 1.2;
+}
+
+.scroll-list {
+  display: grid;
+  gap: 0.52rem;
+  max-height: 320px;
+  overflow-y: auto;
+  padding-right: 0.28rem;
+}
+
+.card {
+  border-radius: 0.72rem;
+  border: 1px solid rgba(161, 218, 203, 0.27);
+  background: rgba(8, 26, 31, 0.83);
+  padding: 0.68rem;
+}
+
+.card-passenger {
+  border-color: rgba(245, 200, 91, 0.38);
+  background: linear-gradient(160deg, rgba(79, 58, 13, 0.33), rgba(8, 26, 31, 0.86));
+}
+
+.card-passenger .card-title {
+  color: #ffe7bc;
+}
+
+.card-flight {
+  border-color: rgba(115, 216, 255, 0.38);
+  background: linear-gradient(160deg, rgba(14, 46, 59, 0.42), rgba(8, 26, 31, 0.86));
+}
+
+.card-flight .card-title {
+  color: #caedff;
+}
+
+.card-top {
+  display: flex;
+  justify-content: space-between;
+  gap: 0.5rem;
+  align-items: center;
+}
+
+.card-title {
+  font-weight: 700;
+}
+
+.card-sub {
+  color: var(--muted);
+  font-size: 0.83rem;
+  margin-top: 0.3rem;
+  line-height: 1.35;
+}
+
+.tier-pill {
+  font-size: 0.7rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  border-radius: 999px;
+  padding: 0.24rem 0.45rem;
+  border: 1px solid rgba(255, 255, 255, 0.2);
+}
+
+.tier-Platinum {
+  color: #fce3a1;
+  border-color: rgba(245, 200, 91, 0.7);
+}
+
+.tier-Gold {
+  color: #ffca87;
+  border-color: rgba(255, 170, 89, 0.72);
+}
+
+.tier-Silver {
+  color: #d6ecf0;
+  border-color: rgba(174, 202, 210, 0.72);
+}
+
+.tier-Standard {
+  color: #b2d0c8;
+  border-color: rgba(158, 204, 192, 0.56);
+}
+
+.result-box {
+  margin-top: 1rem;
+}
+
+.result-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 0.55rem;
+  margin-bottom: 0.45rem;
+}
+
+.result-box h3 {
+  font-size: 0.95rem;
+  margin-bottom: 0;
+}
+
+.latest-summary {
+  border: 1px solid rgba(170, 221, 208, 0.28);
+  border-radius: 0.72rem;
+  background: rgba(4, 16, 18, 0.78);
+  padding: 0.68rem;
+  display: grid;
+  gap: 0.36rem;
+}
+
+.latest-status {
+  font-size: 0.74rem;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  width: fit-content;
+  border-radius: 999px;
+  padding: 0.2rem 0.5rem;
+  border: 1px solid transparent;
+}
+
+.latest-status-active {
+  color: #bff7e8;
+  border-color: rgba(65, 210, 173, 0.58);
+  background: rgba(10, 69, 56, 0.35);
+}
+
+.latest-status-done {
+  color: #fff0bf;
+  border-color: rgba(245, 200, 91, 0.6);
+  background: rgba(98, 74, 18, 0.33);
+}
+
+.latest-status-reset {
+  color: #d2ecff;
+  border-color: rgba(115, 216, 255, 0.58);
+  background: rgba(13, 53, 73, 0.35);
+}
+
+.latest-status-error {
+  color: #ffd0d0;
+  border-color: rgba(255, 109, 109, 0.62);
+  background: rgba(88, 16, 16, 0.36);
+}
+
+.latest-row {
+  display: grid;
+  grid-template-columns: 110px minmax(0, 1fr);
+  gap: 0.55rem;
+  align-items: baseline;
+}
+
+.latest-label {
+  color: var(--muted);
+  font-size: 0.77rem;
+}
+
+.latest-value {
+  color: #e7fbf5;
+  font-size: 0.82rem;
+  font-weight: 600;
+  overflow-wrap: anywhere;
+}
+
+.latest-note {
+  font-size: 0.77rem;
+  color: #bee8dd;
+  line-height: 1.35;
+}
+
+.latest-note-error {
+  color: #ffb5b5;
+}
+
+.latest-empty {
+  color: var(--muted);
+  font-size: 0.82rem;
+}
+
+.latest-raw {
+  margin-top: 0.52rem;
+}
+
+.hidden {
+  display: none !important;
+}
+
+pre {
+  margin: 0;
+  max-height: 210px;
+  overflow: auto;
+  padding: 0.72rem;
+  border-radius: 0.7rem;
+  border: 1px solid rgba(170, 221, 208, 0.28);
+  background: rgba(4, 16, 18, 0.88);
+  color: #d8f7ef;
+  font-size: 0.78rem;
+  line-height: 1.42;
+}
+
+.timeline {
+  animation: reveal-up 640ms ease-out both;
+}
+
+.log-list {
+  display: grid;
+  gap: 0.65rem;
+  max-height: 320px;
+  overflow-y: auto;
+}
+
+.log-item {
+  border-radius: 0.72rem;
+  border: 1px solid rgba(163, 220, 205, 0.22);
+  background: rgba(7, 23, 27, 0.87);
+  padding: 0.65rem;
+}
+
+.log-item strong {
+  color: var(--accent-cool);
+}
+
+.log-meta {
+  color: var(--muted);
+  font-size: 0.8rem;
+  margin-top: 0.2rem;
+}
+
+.empty {
+  border: 1px dashed rgba(173, 223, 210, 0.33);
+  border-radius: 0.72rem;
+  color: var(--muted);
+  padding: 0.72rem;
+}
+
+.empty-passengers {
+  border-color: rgba(245, 200, 91, 0.42);
+  background: rgba(81, 60, 15, 0.2);
+}
+
+.empty-flights {
+  border-color: rgba(115, 216, 255, 0.42);
+  background: rgba(11, 50, 67, 0.22);
+}
+
+.action-console form {
+  display: grid;
+  gap: 0.15rem;
+}
+
+@keyframes reveal-up {
+  from {
+    opacity: 0;
+    transform: translateY(8px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@media (max-width: 1200px) {
+  .grid {
+    grid-template-columns: 1fr 1fr;
+  }
+
+  .action-console {
+    grid-column: 1 / -1;
+  }
+}
+
+@media (max-width: 1380px) {
+  .split {
+    grid-template-columns: 1fr;
+  }
+}
+
+@media (max-width: 760px) {
+  body {
+    padding: 0.75rem;
+  }
+
+  .hero {
+    flex-direction: column;
+  }
+
+  .hero-badges {
+    justify-content: flex-start;
+  }
+
+  .grid {
+    grid-template-columns: 1fr;
+  }
+
+  .metrics {
+    grid-template-columns: 1fr;
+  }
+
+  .latest-row {
+    grid-template-columns: 1fr;
+    gap: 0.2rem;
+  }
+}

inference.py

@@ -0,0 +1,1022 @@
+"""
+Submission inference runner.
+
+Requirements covered:
+- Script name is inference.py in repo root.
+- Uses OpenAI client for model calls.
+- Uses internal Groq + Llama 8B defaults (overridable via environment).
+- Emits structured stdout logs with [START], [STEP], [END].
+"""
+
+import argparse
+from copy import deepcopy
+import json
+import os
+import pickle
+import re
+import sys
+from typing import Any, Dict, List, Optional
+
+from openai import OpenAI
+
+from environment import Action, ActionType, CabinClass, FlightRebookingEnv, PriorityTier
+from ml_policy import choose_action_from_ranked_types, observation_to_features
+from tasks import TASKS, grade_task
+
+
+SYSTEM_PROMPT = """You are an airline disruption operations agent.
+
+Return exactly one JSON object on each turn with this schema:
+{
+  \"action_type\": \"rebook_passenger\" | \"offer_downgrade\" | \"book_hotel\" | \"rebook_on_partner\" | \"mark_no_solution\" | \"finalize\",
+  \"passenger_id\": \"optional passenger id\",
+  \"flight_id\": \"optional flight id\"
+}
+
+Policy:
+- Process one pending passenger per step.
+- Respect tiers (Platinum > Gold > Silver > Standard).
+- Prefer earlier departures for deadline passengers.
+- Prefer same-airline rebooking over partner when feasible.
+- Minimize budget usage.
+- Output raw JSON only.
+"""
+
+DEFAULT_API_BASE_URL = "https://api.groq.com/openai/v1"
+DEFAULT_LLM_MODEL = "llama-3.1-8b-instant"
+INTERNAL_GROQ_API_KEY = ""
+BENCHMARK_NAME = os.getenv("BENCHMARK", "flight-rebooking-openenv")
+SUCCESS_SCORE_THRESHOLD = 0.1
+GIT_LFS_POINTER_HEADER = "version https://git-lfs.github.com/spec/v1"
+
+
+def _first_non_empty(*values: str) -> str:
+    for value in values:
+        cleaned = (value or "").strip()
+        if cleaned:
+            return cleaned
+    return ""
+
+
+def _resolve_model_config() -> Dict[str, str]:
+    api_base_url = _first_non_empty(
+        os.getenv("API_BASE_URL", ""),
+        os.getenv("OPENAI_BASE_URL", ""),
+        DEFAULT_API_BASE_URL,
+    )
+    model_name = _first_non_empty(
+        os.getenv("MODEL_NAME", ""),
+        os.getenv("OPENAI_MODEL", ""),
+        DEFAULT_LLM_MODEL,
+    )
+    api_key = _first_non_empty(
+        os.getenv("GROQ_API_KEY", ""),
+        os.getenv("HF_TOKEN", ""),
+        os.getenv("OPENAI_API_KEY", ""),
+        INTERNAL_GROQ_API_KEY,
+    )
+
+    if not api_key:
+        raise SystemExit(
+            "No API key configured. Set GROQ_API_KEY (preferred), OPENAI_API_KEY, or HF_TOKEN."
+        )
+
+    return {
+        "api_base_url": api_base_url,
+        "model_name": model_name,
+        "api_key": api_key,
+    }
+
+
+def _load_ml_policy_artifact(path: str) -> Optional[Dict[str, Any]]:
+    if not path:
+        return None
+    if not os.path.exists(path):
+        return None
+
+    try:
+        with open(path, "rb") as handle:
+            artifact = pickle.load(handle)
+    except Exception as exc:
+        print(f"[WARN] Failed to load ML policy artifact at {path}: {exc}", file=sys.stderr)
+        return None
+
+    if not isinstance(artifact, dict) or "model" not in artifact:
+        print(f"[WARN] Invalid ML policy artifact format at {path}; ignoring.", file=sys.stderr)
+        return None
+
+    return artifact
+
+
+def _is_git_lfs_pointer_file(path: str) -> bool:
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            lines = [handle.readline().strip() for _ in range(3)]
+    except (UnicodeDecodeError, OSError):
+        return False
+
+    if not lines or lines[0] != GIT_LFS_POINTER_HEADER:
+        return False
+
+    return any(line.startswith("oid sha256:") for line in lines[1:])
+
+
+def _ml_policy_fix_instructions(path: str) -> str:
+    return (
+        "Fix options:\n"
+        "1) Materialize artifact bytes with Git LFS (if this repo stores models in LFS):\n"
+        f"   git lfs pull --include \"{path}\"\n"
+        "2) Regenerate the artifact locally:\n"
+        "   python train_ml_policy.py --episodes-per-task 450 --seed 42 --output artifacts/ml_policy.pkl --report artifacts/ml_policy_report.json"
+    )
+
+
+def _require_ml_policy_artifact(path: str, policy_name: str) -> Dict[str, Any]:
+    if not path:
+        raise SystemExit(
+            f"Policy '{policy_name}' requires --ml-policy-path.\n"
+            + _ml_policy_fix_instructions("artifacts/ml_policy.pkl")
+        )
+
+    if not os.path.exists(path):
+        raise SystemExit(
+            f"Policy '{policy_name}' requires an ML artifact, but '{path}' was not found.\n"
+            + _ml_policy_fix_instructions(path)
+        )
+
+    if _is_git_lfs_pointer_file(path):
+        raise SystemExit(
+            f"Policy '{policy_name}' cannot run because '{path}' is a Git LFS pointer, not a pickle artifact.\n"
+            + _ml_policy_fix_instructions(path)
+        )
+
+    artifact = _load_ml_policy_artifact(path)
+    if artifact is None:
+        raise SystemExit(
+            f"Policy '{policy_name}' requires a valid ML artifact, but '{path}' could not be loaded as a pickle.\n"
+            + _ml_policy_fix_instructions(path)
+        )
+
+    return artifact
+
+
+def _rank_action_types_from_model(model: Any, features: List[float]) -> List[str]:
+    ranked: List[str]
+
+    if hasattr(model, "predict_proba") and hasattr(model, "classes_"):
+        probabilities = model.predict_proba([features])[0]
+        classes = [str(cls) for cls in model.classes_]
+        ranked = [
+            label
+            for _, label in sorted(
+                zip(probabilities, classes),
+                key=lambda item: item[0],
+                reverse=True,
+            )
+        ]
+    else:
+        ranked = [str(model.predict([features])[0])]
+
+    for action_type in (
+        ActionType.REBOOK_PASSENGER.value,
+        ActionType.OFFER_DOWNGRADE.value,
+        ActionType.REBOOK_ON_PARTNER.value,
+        ActionType.BOOK_HOTEL.value,
+        ActionType.MARK_NO_SOLUTION.value,
+        ActionType.FINALIZE.value,
+    ):
+        if action_type not in ranked:
+            ranked.append(action_type)
+
+    return ranked
+
+
+def _predict_ml_policy_action(observation: Dict[str, Any], ml_policy_artifact: Dict[str, Any]) -> Dict[str, Any]:
+    model = ml_policy_artifact["model"]
+    features = observation_to_features(observation)
+    ranked_action_types = _rank_action_types_from_model(model, features)
+    return choose_action_from_ranked_types(observation, ranked_action_types)
+
+
+def _predict_ml_ranked_action_types(observation: Dict[str, Any], ml_policy_artifact: Dict[str, Any]) -> List[str]:
+    model = ml_policy_artifact["model"]
+    features = observation_to_features(observation)
+    return _rank_action_types_from_model(model, features)
+
+
+def _feasible_actions_from_observation(observation: Dict[str, Any]) -> List[Action]:
+    pending = list(observation.get("pending_passengers", []))
+    flights = list(observation.get("available_flights", []))
+    budget_remaining = float(observation.get("budget_remaining", 0.0))
+
+    if not pending:
+        return [Action(action_type=ActionType.FINALIZE)]
+
+    actions: List[Action] = []
+    for passenger in pending:
+        for flight in flights:
+            if (not flight.get("is_partner", False)) and _has_seat(flight, str(passenger.get("cabin_class", ""))):
+                actions.append(
+                    Action(
+                        action_type=ActionType.REBOOK_PASSENGER,
+                        passenger_id=passenger["id"],
+                        flight_id=flight["id"],
+                    )
+                )
+
+            if (
+                passenger.get("cabin_class") == CabinClass.BUSINESS.value
+                and (not flight.get("is_partner", False))
+                and int(flight.get("economy_seats", 0)) > 0
+                and budget_remaining >= 500.0
+            ):
+                actions.append(
+                    Action(
+                        action_type=ActionType.OFFER_DOWNGRADE,
+                        passenger_id=passenger["id"],
+                        flight_id=flight["id"],
+                    )
+                )
+
+            if (
+                flight.get("is_partner", False)
+                and _has_seat(flight, str(passenger.get("cabin_class", "")))
+                and budget_remaining >= 800.0
+            ):
+                actions.append(
+                    Action(
+                        action_type=ActionType.REBOOK_ON_PARTNER,
+                        passenger_id=passenger["id"],
+                        flight_id=flight["id"],
+                    )
+                )
+
+        if budget_remaining >= 250.0:
+            actions.append(
+                Action(
+                    action_type=ActionType.BOOK_HOTEL,
+                    passenger_id=passenger["id"],
+                )
+            )
+
+        actions.append(
+            Action(
+                action_type=ActionType.MARK_NO_SOLUTION,
+                passenger_id=passenger["id"],
+            )
+        )
+
+    actions.append(Action(action_type=ActionType.FINALIZE))
+    return actions
+
+
+def _action_cost(action_type: ActionType) -> float:
+    return {
+        ActionType.REBOOK_PASSENGER: 0.0,
+        ActionType.OFFER_DOWNGRADE: 500.0,
+        ActionType.BOOK_HOTEL: 250.0,
+        ActionType.REBOOK_ON_PARTNER: 800.0,
+        ActionType.MARK_NO_SOLUTION: 0.0,
+        ActionType.FINALIZE: 0.0,
+    }.get(action_type, 0.0)
+
+
+def _action_priority_score(observation: Dict[str, Any], action: Action) -> float:
+    pending = list(observation.get("pending_passengers", []))
+    if action.action_type == ActionType.FINALIZE:
+        return 10.0 if not pending else -10.0
+
+    pending_by_id = {p["id"]: p for p in pending}
+    flights_by_id = {f["id"]: f for f in observation.get("available_flights", [])}
+
+    passenger = pending_by_id.get(action.passenger_id or "")
+    if passenger is None:
+        return -100.0
+
+    tier_component = _tier_weight(str(passenger.get("priority_tier", ""))) / 4.0
+    deadline = passenger.get("connection_deadline_hrs")
+    if deadline is None:
+        deadline_component = 0.0
+    else:
+        deadline_component = (12.0 - min(max(float(deadline), 0.0), 12.0)) / 12.0
+
+    score = (0.65 * tier_component) + (0.35 * deadline_component)
+
+    type_bonus = {
+        ActionType.REBOOK_PASSENGER: 0.60,
+        ActionType.OFFER_DOWNGRADE: 0.30,
+        ActionType.REBOOK_ON_PARTNER: 0.18,
+        ActionType.BOOK_HOTEL: 0.10,
+        ActionType.MARK_NO_SOLUTION: -0.60,
+        ActionType.FINALIZE: 0.0,
+    }[action.action_type]
+    score += type_bonus
+
+    if action.flight_id:
+        flight = flights_by_id.get(action.flight_id)
+        if flight is not None and deadline is not None:
+            departure = float(flight.get("departure_hrs", 99.0))
+            if departure <= float(deadline):
+                score += 0.22
+            else:
+                score -= 0.22
+
+    budget_remaining = float(observation.get("budget_remaining", 0.0))
+    budget_spent = float(observation.get("budget_spent", 0.0))
+    budget_total = max(budget_remaining + budget_spent, 1.0)
+    score -= 0.35 * min(_action_cost(action.action_type) / budget_total, 1.0)
+
+    return score
+
+
+def _prune_candidate_actions(
+    observation: Dict[str, Any],
+    actions: List[Action],
+    ranked_action_types: Optional[List[str]],
+    max_candidates: int,
+) -> List[Action]:
+    deduped: List[Action] = []
+    seen = set()
+    for action in actions:
+        signature = (action.action_type.value, action.passenger_id, action.flight_id)
+        if signature in seen:
+            continue
+        seen.add(signature)
+        deduped.append(action)
+
+    rank_index: Dict[str, int] = {}
+    if ranked_action_types:
+        rank_index = {action_type: idx for idx, action_type in enumerate(ranked_action_types)}
+
+    deduped.sort(
+        key=lambda action: (
+            rank_index.get(action.action_type.value, 999),
+            -_action_priority_score(observation, action),
+        )
+    )
+    return deduped[: max(1, max_candidates)]
+
+
+def _rollout_heuristic_to_end(env: FlightRebookingEnv) -> None:
+    done = False
+    while not done:
+        observation = env._get_observation().model_dump(mode="json")
+        action = Action(**_heuristic_action(observation))
+        _, _, done, _ = env.step(action)
+
+
+def _evaluate_state_with_lookahead(
+    env: FlightRebookingEnv,
+    task_key: str,
+    lookahead_depth: int,
+    lookahead_width: int,
+    ranked_action_types: Optional[List[str]] = None,
+) -> float:
+    observation = env._get_observation().model_dump(mode="json")
+    candidate_actions = _feasible_actions_from_observation(observation)
+
+    if ranked_action_types:
+        preferred_types = set(ranked_action_types[:5])
+        preferred_types.add(ActionType.FINALIZE.value)
+        preferred_types.add(ActionType.MARK_NO_SOLUTION.value)
+        preferred_candidates = [a for a in candidate_actions if a.action_type.value in preferred_types]
+        if preferred_candidates:
+            candidate_actions = preferred_candidates
+
+    candidate_actions = _prune_candidate_actions(
+        observation=observation,
+        actions=candidate_actions,
+        ranked_action_types=ranked_action_types,
+        max_candidates=lookahead_width,
+    )
+
+    best_score = -1.0
+    for action in candidate_actions:
+        env_copy = deepcopy(env)
+        _, _, done, _ = env_copy.step(action)
+
+        if done:
+            score = float(grade_task(task_key, env_copy.state(), TASKS[task_key]["max_budget"]))
+        elif lookahead_depth <= 1:
+            _rollout_heuristic_to_end(env_copy)
+            score = float(grade_task(task_key, env_copy.state(), TASKS[task_key]["max_budget"]))
+        else:
+            score = _evaluate_state_with_lookahead(
+                env=env_copy,
+                task_key=task_key,
+                lookahead_depth=lookahead_depth - 1,
+                lookahead_width=lookahead_width,
+                ranked_action_types=None,
+            )
+
+        if score > best_score:
+            best_score = score
+
+    if best_score >= 0.0:
+        return best_score
+
+    env_fallback = deepcopy(env)
+    _rollout_heuristic_to_end(env_fallback)
+    return float(grade_task(task_key, env_fallback.state(), TASKS[task_key]["max_budget"]))
+
+
+def _projected_score_for_action(
+    env: FlightRebookingEnv,
+    task_key: str,
+    action: Action,
+    lookahead_depth: int,
+    lookahead_width: int,
+) -> float:
+    env_copy = deepcopy(env)
+    _, _, done, _ = env_copy.step(action)
+    if done:
+        return float(grade_task(task_key, env_copy.state(), TASKS[task_key]["max_budget"]))
+
+    if lookahead_depth <= 1:
+        _rollout_heuristic_to_end(env_copy)
+        return float(grade_task(task_key, env_copy.state(), TASKS[task_key]["max_budget"]))
+
+    return _evaluate_state_with_lookahead(
+        env=env_copy,
+        task_key=task_key,
+        lookahead_depth=lookahead_depth - 1,
+        lookahead_width=lookahead_width,
+        ranked_action_types=None,
+    )
+
+
+def _choose_lookahead_action(
+    env: FlightRebookingEnv,
+    task_key: str,
+    lookahead_depth: int,
+    lookahead_width: int,
+    ranked_action_types: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    observation = env._get_observation().model_dump(mode="json")
+    candidate_actions = _feasible_actions_from_observation(observation)
+
+    if ranked_action_types:
+        preferred_types = set(ranked_action_types[:5])
+        preferred_types.add(ActionType.FINALIZE.value)
+        preferred_types.add(ActionType.MARK_NO_SOLUTION.value)
+        preferred_candidates = [a for a in candidate_actions if a.action_type.value in preferred_types]
+        if preferred_candidates:
+            candidate_actions = preferred_candidates
+
+    best_action = candidate_actions[0]
+    best_score = -1.0
+    for action in candidate_actions:
+        try:
+            projected_score = _projected_score_for_action(
+                env=env,
+                task_key=task_key,
+                action=action,
+                lookahead_depth=lookahead_depth,
+                lookahead_width=lookahead_width,
+            )
+        except Exception:
+            continue
+        if projected_score > best_score:
+            best_score = projected_score
+            best_action = action
+
+    return best_action.model_dump(mode="json")
+
+
+def _pick_best_payload_by_projection(
+    env: FlightRebookingEnv,
+    task_key: str,
+    payloads: List[Dict[str, Any]],
+    lookahead_depth: int,
+    lookahead_width: int,
+) -> Dict[str, Any]:
+    best_payload = payloads[0]
+    best_score = -1.0
+
+    seen_signatures = set()
+    for payload in payloads:
+        try:
+            action = Action(**payload)
+        except Exception:
+            continue
+
+        signature = (action.action_type.value, action.passenger_id, action.flight_id)
+        if signature in seen_signatures:
+            continue
+        seen_signatures.add(signature)
+
+        try:
+            projected_score = _projected_score_for_action(
+                env=env,
+                task_key=task_key,
+                action=action,
+                lookahead_depth=lookahead_depth,
+                lookahead_width=lookahead_width,
+            )
+        except Exception:
+            continue
+
+        if projected_score > best_score:
+            best_score = projected_score
+            best_payload = action.model_dump(mode="json")
+
+    return best_payload
+
+
+def _extract_json(text: str) -> Dict[str, Any]:
+    text = (text or "").strip()
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+
+    fenced = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
+    if fenced:
+        return json.loads(fenced.group(1))
+
+    inline = re.search(r"\{.*\}", text, re.DOTALL)
+    if inline:
+        return json.loads(inline.group(0))
+
+    raise ValueError("No valid JSON action in model output")
+
+
+def _tier_weight(tier: str) -> int:
+    return {
+        PriorityTier.PLATINUM.value: 4,
+        PriorityTier.GOLD.value: 3,
+        PriorityTier.SILVER.value: 2,
+        PriorityTier.STANDARD.value: 1,
+    }.get(tier, 1)
+
+
+def _has_seat(flight: Dict[str, Any], cabin_class: str) -> bool:
+    if cabin_class == CabinClass.BUSINESS.value:
+        return flight["business_seats"] > 0
+    return flight["economy_seats"] > 0
+
+
+def _heuristic_action(observation: Dict[str, Any]) -> Dict[str, Any]:
+    pending = list(observation["pending_passengers"])
+    if not pending:
+        return {"action_type": ActionType.FINALIZE.value}
+
+    pending.sort(
+        key=lambda p: (
+            -_tier_weight(p["priority_tier"]),
+            p["connection_deadline_hrs"] if p["connection_deadline_hrs"] is not None else 10**9,
+        )
+    )
+
+    passenger = pending[0]
+    flights = sorted(observation["available_flights"], key=lambda f: f["departure_hrs"])
+
+    for flight in flights:
+        if flight["is_partner"]:
+            continue
+        if _has_seat(flight, passenger["cabin_class"]):
+            return {
+                "action_type": ActionType.REBOOK_PASSENGER.value,
+                "passenger_id": passenger["id"],
+                "flight_id": flight["id"],
+            }
+
+    if passenger["cabin_class"] == CabinClass.BUSINESS.value:
+        for flight in flights:
+            if flight["is_partner"]:
+                continue
+            if flight["economy_seats"] > 0 and observation["budget_remaining"] >= 500:
+                return {
+                    "action_type": ActionType.OFFER_DOWNGRADE.value,
+                    "passenger_id": passenger["id"],
+                    "flight_id": flight["id"],
+                }
+
+    for flight in flights:
+        if not flight["is_partner"]:
+            continue
+        if _has_seat(flight, passenger["cabin_class"]) and observation["budget_remaining"] >= 800:
+            return {
+                "action_type": ActionType.REBOOK_ON_PARTNER.value,
+                "passenger_id": passenger["id"],
+                "flight_id": flight["id"],
+            }
+
+    if observation["budget_remaining"] >= 250:
+        return {
+            "action_type": ActionType.BOOK_HOTEL.value,
+            "passenger_id": passenger["id"],
+        }
+
+    return {
+        "action_type": ActionType.MARK_NO_SOLUTION.value,
+        "passenger_id": passenger["id"],
+    }
+
+
+def _is_action_feasible(observation: Dict[str, Any], payload: Dict[str, Any]) -> bool:
+    action_type = payload["action_type"]
+    if action_type == ActionType.FINALIZE.value:
+        return True
+
+    pending_by_id = {p["id"]: p for p in observation["pending_passengers"]}
+    flights_by_id = {f["id"]: f for f in observation["available_flights"]}
+    budget_remaining = float(observation["budget_remaining"])
+
+    passenger = pending_by_id.get(payload.get("passenger_id"))
+    if passenger is None:
+        return False
+
+    if action_type == ActionType.BOOK_HOTEL.value:
+        return budget_remaining >= 250
+
+    if action_type == ActionType.MARK_NO_SOLUTION.value:
+        return True
+
+    flight = flights_by_id.get(payload.get("flight_id"))
+    if flight is None:
+        return False
+
+    passenger_cabin = passenger["cabin_class"]
+    needs_business = passenger_cabin == CabinClass.BUSINESS.value
+    has_matching_cabin_seat = (flight["business_seats"] > 0) if needs_business else (flight["economy_seats"] > 0)
+
+    if action_type == ActionType.REBOOK_PASSENGER.value:
+        return (not flight["is_partner"]) and has_matching_cabin_seat
+
+    if action_type == ActionType.OFFER_DOWNGRADE.value:
+        return (
+            passenger_cabin == CabinClass.BUSINESS.value
+            and budget_remaining >= 500
+            and flight["economy_seats"] > 0
+        )
+
+    if action_type == ActionType.REBOOK_ON_PARTNER.value:
+        return flight["is_partner"] and budget_remaining >= 800 and has_matching_cabin_seat
+
+    return False
+
+
+def _sanitize_action_payload(observation: Dict[str, Any], payload: Any) -> Dict[str, Any]:
+    fallback = _heuristic_action(observation)
+
+    if not isinstance(payload, dict):
+        return fallback
+
+    valid_action_types = {action_type.value for action_type in ActionType}
+    action_type = str(payload.get("action_type", "")).strip()
+    if action_type not in valid_action_types:
+        return fallback
+
+    sanitized: Dict[str, Any] = {"action_type": action_type}
+    passenger_id = str(payload.get("passenger_id", "")).strip()
+    flight_id = str(payload.get("flight_id", "")).strip()
+
+    if passenger_id:
+        sanitized["passenger_id"] = passenger_id
+    if flight_id:
+        sanitized["flight_id"] = flight_id
+
+    if action_type == ActionType.FINALIZE.value:
+        return sanitized
+
+    pending_ids = {p["id"] for p in observation["pending_passengers"]}
+    if sanitized.get("passenger_id") not in pending_ids:
+        return fallback
+
+    if action_type in {
+        ActionType.REBOOK_PASSENGER.value,
+        ActionType.OFFER_DOWNGRADE.value,
+        ActionType.REBOOK_ON_PARTNER.value,
+    }:
+        flight_ids = {f["id"] for f in observation["available_flights"]}
+        if sanitized.get("flight_id") not in flight_ids:
+            return fallback
+
+    if not _is_action_feasible(observation, sanitized):
+        return fallback
+
+    return sanitized
+
+
+def _query_openai_action(
+    client: OpenAI,
+    model_name: str,
+    seed: int,
+    observation_json: str,
+    policy_hint_json: Optional[str] = None,
+    max_retries: int = 2,
+) -> Dict[str, Any]:
+    last_error: Optional[Exception] = None
+
+    for _ in range(max_retries + 1):
+        try:
+            user_content = f"Current observation: {observation_json}"
+            if policy_hint_json:
+                user_content += (
+                    "\nSuggested safe action from a trained policy: "
+                    f"{policy_hint_json}"
+                    "\nPrefer this if it is valid for the current observation."
+                )
+
+            kwargs: Dict[str, Any] = {
+                "model": model_name,
+                "messages": [
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": user_content},
+                ],
+                "temperature": 0,
+                "top_p": 1,
+                "max_tokens": 220,
+                "seed": seed,
+            }
+
+            response = None
+            try:
+                response = client.chat.completions.create(**kwargs)
+            except TypeError:
+                kwargs.pop("seed", None)
+                response = client.chat.completions.create(**kwargs)
+
+            content = response.choices[0].message.content or ""
+            return _extract_json(content)
+        except Exception as exc:
+            last_error = exc
+
+    raise RuntimeError(f"OpenAI call failed after retries: {last_error}")
+
+
+def _emit_start(task_name: str, benchmark: str, model_name: str) -> None:
+    print(f"[START] task={task_name} env={benchmark} model={model_name}", flush=True)
+
+
+def _format_action_for_log(action: Action) -> str:
+    payload = {
+        "action_type": action.action_type.value,
+        "passenger_id": action.passenger_id,
+        "flight_id": action.flight_id,
+    }
+    return json.dumps(payload, separators=(",", ":"), ensure_ascii=True)
+
+
+def _emit_step(
+    step_index: int,
+    action_text: str,
+    reward_value: float,
+    done: bool,
+    error: Optional[str],
+) -> None:
+    done_value = str(bool(done)).lower()
+    error_value = error if error else "null"
+    print(
+        "[STEP] "
+        f"step={step_index} "
+        f"action={action_text} "
+        f"reward={reward_value:.2f} "
+        f"done={done_value} "
+        f"error={error_value}",
+        flush=True,
+    )
+
+
+def _emit_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    rewards_text = ",".join(f"{value:.2f}" for value in rewards)
+    success_value = str(bool(success)).lower()
+    print(
+        "[END] "
+        f"success={success_value} "
+        f"steps={steps} "
+        f"score={score:.4f} "
+        f"rewards={rewards_text}",
+        flush=True,
+    )
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run submission inference across OpenEnv tasks.")
+    parser.add_argument("--task", choices=["all", "easy", "medium", "hard"], default="all")
+    parser.add_argument("--seed", type=int, default=int(os.getenv("BASELINE_SEED", "42")))
+    parser.add_argument(
+        "--policy",
+        choices=["openai", "heuristic", "trained_ml", "openai_trained"],
+        default="openai_trained",
+        help=(
+            "Policy backend. openai_trained uses Llama with trained-policy hints; "
+            "trained_ml uses the learned policy directly; openai and heuristic remain available."
+        ),
+    )
+    parser.add_argument(
+        "--ml-policy-path",
+        default=os.getenv("ML_POLICY_PATH", "artifacts/ml_policy.pkl"),
+        help="Path to trained ML policy artifact used by trained_ml/openai_trained modes.",
+    )
+    parser.add_argument(
+        "--lookahead-depth",
+        type=int,
+        default=int(os.getenv("LOOKAHEAD_DEPTH", "2")),
+        help="Lookahead depth for projected action scoring (>=1).",
+    )
+    parser.add_argument(
+        "--lookahead-width",
+        type=int,
+        default=int(os.getenv("LOOKAHEAD_WIDTH", "12")),
+        help="Maximum candidate actions explored per lookahead level (>=1).",
+    )
+    parser.add_argument("--json-out", default="", help="Optional JSON output path.")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    args.lookahead_depth = max(1, int(args.lookahead_depth))
+    args.lookahead_width = max(1, int(args.lookahead_width))
+
+    task_keys = ["easy", "medium", "hard"] if args.task == "all" else [args.task]
+
+    effective_policy = args.policy
+    ml_policy_artifact: Optional[Dict[str, Any]] = None
+    if effective_policy in {"trained_ml", "openai_trained"}:
+        ml_policy_artifact = _require_ml_policy_artifact(args.ml_policy_path, effective_policy)
+
+    api_base_url = "heuristic"
+    model_name = "heuristic"
+    client: Optional[OpenAI] = None
+    if effective_policy in {"openai", "openai_trained"}:
+        model_config = _resolve_model_config()
+        api_base_url = model_config["api_base_url"]
+        model_name = model_config["model_name"]
+        client = OpenAI(api_key=model_config["api_key"], base_url=api_base_url)
+
+    results: List[Dict[str, Any]] = []
+
+    for task_key in task_keys:
+        task_data = TASKS[task_key]
+        _emit_start(task_name=task_data["task_id"], benchmark=BENCHMARK_NAME, model_name=model_name)
+
+        env = FlightRebookingEnv(task_data=task_data)
+        observation = None
+        done = False
+        steps = 0
+        rewards: List[float] = []
+        score = 0.01
+        success = False
+        episode_error: Optional[str] = None
+
+        try:
+            observation = env.reset()
+
+            while not done:
+                observation_dict = observation.model_dump(mode="json")
+
+                if effective_policy in {"openai", "openai_trained"}:
+                    assert client is not None
+                    policy_hint_payload: Optional[Dict[str, Any]] = None
+                    if effective_policy == "openai_trained":
+                        assert ml_policy_artifact is not None
+                        ranked_types = _predict_ml_ranked_action_types(observation_dict, ml_policy_artifact)
+                        policy_hint_payload = _choose_lookahead_action(
+                            env=env,
+                            task_key=task_key,
+                            lookahead_depth=args.lookahead_depth,
+                            lookahead_width=args.lookahead_width,
+                            ranked_action_types=ranked_types,
+                        )
+
+                    raw_payload = _query_openai_action(
+                        client=client,
+                        model_name=model_name,
+                        seed=args.seed,
+                        observation_json=observation.model_dump_json(),
+                        policy_hint_json=(json.dumps(policy_hint_payload) if policy_hint_payload is not None else None),
+                    )
+                    llm_payload = _sanitize_action_payload(observation_dict, raw_payload)
+
+                    if effective_policy == "openai_trained" and policy_hint_payload is not None:
+                        action_payload = _pick_best_payload_by_projection(
+                            env=env,
+                            task_key=task_key,
+                            payloads=[policy_hint_payload, llm_payload],
+                            lookahead_depth=args.lookahead_depth,
+                            lookahead_width=args.lookahead_width,
+                        )
+                    else:
+                        action_payload = llm_payload
+                elif effective_policy == "trained_ml":
+                    assert ml_policy_artifact is not None
+                    ranked_types = _predict_ml_ranked_action_types(observation_dict, ml_policy_artifact)
+                    action_payload = _choose_lookahead_action(
+                        env=env,
+                        task_key=task_key,
+                        lookahead_depth=args.lookahead_depth,
+                        lookahead_width=args.lookahead_width,
+                        ranked_action_types=ranked_types,
+                    )
+                else:
+                    action_payload = _heuristic_action(observation_dict)
+
+                try:
+                    action = Action(**action_payload)
+                except Exception:
+                    action = Action(action_type=ActionType.FINALIZE)
+
+                step_error: Optional[str] = None
+                reward_value = 0.0
+                try:
+                    observation, reward, done, info = env.step(action)
+                    reward_value = float(reward.value)
+                    if isinstance(info, dict) and info.get("error"):
+                        step_error = str(info.get("error"))
+                except Exception as exc:
+                    done = True
+                    step_error = str(exc)
+                    episode_error = step_error
+
+                steps += 1
+                rewards.append(reward_value)
+                _emit_step(
+                    step_index=steps,
+                    action_text=_format_action_for_log(action),
+                    reward_value=reward_value,
+                    done=done,
+                    error=step_error,
+                )
+
+            try:
+                final_state = env.state()
+                score = float(grade_task(task_key, final_state, task_data["max_budget"]))
+            except Exception as exc:
+                episode_error = str(exc)
+                score = 0.01
+        except Exception as exc:
+            episode_error = str(exc)
+            score = 0.01
+        finally:
+            close_fn = getattr(env, "close", None)
+            if callable(close_fn):
+                try:
+                    close_fn()
+                except Exception as exc:
+                    if not episode_error:
+                        episode_error = str(exc)
+
+            success = (episode_error is None) and (0.0 <= score <= 1.0) and (score >= SUCCESS_SCORE_THRESHOLD)
+            _emit_end(success=success, steps=steps, score=score, rewards=rewards)
+
+            try:
+                final_state = env.state()
+                avg_step_reward = sum(rewards) / max(len(rewards), 1)
+                results.append(
+                    {
+                        "task": task_key,
+                        "task_id": task_data["task_id"],
+                        "difficulty": task_data["difficulty"],
+                        "steps": steps,
+                        "avg_step_reward": round(avg_step_reward, 4),
+                        "score": round(score, 4),
+                        "budget_spent": round(final_state.budget_spent, 2),
+                        "budget_max": task_data["max_budget"],
+                        "invalid_actions": final_state.invalid_actions,
+                        "success": success,
+                        "error": episode_error,
+                    }
+                )
+            except Exception:
+                avg_step_reward = sum(rewards) / max(len(rewards), 1)
+                results.append(
+                    {
+                        "task": task_key,
+                        "task_id": task_data["task_id"],
+                        "difficulty": task_data["difficulty"],
+                        "steps": steps,
+                        "avg_step_reward": round(avg_step_reward, 4),
+                        "score": round(score, 4),
+                        "budget_spent": None,
+                        "budget_max": task_data["max_budget"],
+                        "invalid_actions": None,
+                        "success": success,
+                        "error": episode_error,
+                    }
+                )
+
+    overall = sum(item["score"] for item in results) / max(len(results), 1)
+
+    if args.json_out:
+        payload = {
+            "policy_requested": args.policy,
+            "policy_effective": effective_policy,
+            "seed": args.seed,
+            "api_base_url": api_base_url,
+            "model_name": model_name,
+            "ml_policy_path": args.ml_policy_path,
+            "ml_policy_loaded": ml_policy_artifact is not None,
+            "lookahead_depth": args.lookahead_depth,
+            "lookahead_width": args.lookahead_width,
+            "overall_score": round(overall, 4),
+            "tasks": results,
+        }
+        with open(args.json_out, "w", encoding="utf-8") as handle:
+            json.dump(payload, handle, indent=2)
+
+
+if __name__ == "__main__":
+    main()

ml_policy.py

@@ -0,0 +1,276 @@
+"""
+ML policy helpers for flight rebooking.
+
+This module provides:
+- deterministic expert policy used for dataset generation,
+- fixed-length feature extraction for supervised learning,
+- safe action construction from ranked action-type preferences.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List, Optional
+
+from environment import ActionType, CabinClass, PriorityTier
+
+
+ACTION_TYPE_ORDER: List[str] = [
+    ActionType.REBOOK_PASSENGER.value,
+    ActionType.OFFER_DOWNGRADE.value,
+    ActionType.REBOOK_ON_PARTNER.value,
+    ActionType.BOOK_HOTEL.value,
+    ActionType.MARK_NO_SOLUTION.value,
+    ActionType.FINALIZE.value,
+]
+
+
+def _tier_weight(tier: str) -> int:
+    return {
+        PriorityTier.PLATINUM.value: 4,
+        PriorityTier.GOLD.value: 3,
+        PriorityTier.SILVER.value: 2,
+        PriorityTier.STANDARD.value: 1,
+    }.get(tier, 1)
+
+
+def _deadline_sort_value(deadline_hrs: Optional[float]) -> float:
+    return float(deadline_hrs) if deadline_hrs is not None else 10**9
+
+
+def _has_seat(flight: Dict[str, Any], cabin_class: str) -> bool:
+    if cabin_class == CabinClass.BUSINESS.value:
+        return int(flight["business_seats"]) > 0
+    return int(flight["economy_seats"]) > 0
+
+
+def _sorted_pending_passengers(observation: Dict[str, Any]) -> List[Dict[str, Any]]:
+    pending = list(observation.get("pending_passengers", []))
+    pending.sort(
+        key=lambda p: (
+            -_tier_weight(str(p.get("priority_tier", ""))),
+            _deadline_sort_value(p.get("connection_deadline_hrs")),
+        )
+    )
+    return pending
+
+
+def _sorted_flights(observation: Dict[str, Any]) -> List[Dict[str, Any]]:
+    flights = list(observation.get("available_flights", []))
+    flights.sort(key=lambda f: float(f.get("departure_hrs", 10**9)))
+    return flights
+
+
+def heuristic_action(observation: Dict[str, Any]) -> Dict[str, Any]:
+    pending = _sorted_pending_passengers(observation)
+    if not pending:
+        return {"action_type": ActionType.FINALIZE.value}
+
+    passenger = pending[0]
+    flights = _sorted_flights(observation)
+
+    for flight in flights:
+        if flight.get("is_partner", False):
+            continue
+        if _has_seat(flight, str(passenger["cabin_class"])):
+            return {
+                "action_type": ActionType.REBOOK_PASSENGER.value,
+                "passenger_id": passenger["id"],
+                "flight_id": flight["id"],
+            }
+
+    if passenger.get("cabin_class") == CabinClass.BUSINESS.value:
+        for flight in flights:
+            if flight.get("is_partner", False):
+                continue
+            if int(flight.get("economy_seats", 0)) > 0 and float(observation.get("budget_remaining", 0.0)) >= 500.0:
+                return {
+                    "action_type": ActionType.OFFER_DOWNGRADE.value,
+                    "passenger_id": passenger["id"],
+                    "flight_id": flight["id"],
+                }
+
+    for flight in flights:
+        if not flight.get("is_partner", False):
+            continue
+        if _has_seat(flight, str(passenger["cabin_class"])) and float(observation.get("budget_remaining", 0.0)) >= 800.0:
+            return {
+                "action_type": ActionType.REBOOK_ON_PARTNER.value,
+                "passenger_id": passenger["id"],
+                "flight_id": flight["id"],
+            }
+
+    if float(observation.get("budget_remaining", 0.0)) >= 250.0:
+        return {
+            "action_type": ActionType.BOOK_HOTEL.value,
+            "passenger_id": passenger["id"],
+        }
+
+    return {
+        "action_type": ActionType.MARK_NO_SOLUTION.value,
+        "passenger_id": passenger["id"],
+    }
+
+
+def observation_to_features(
+    observation: Dict[str, Any],
+    max_pending: int = 5,
+    max_flights: int = 6,
+) -> List[float]:
+    pending = _sorted_pending_passengers(observation)
+    flights = _sorted_flights(observation)
+
+    processed_count = float(observation.get("processed_count", 0))
+    total_passengers = max(float(observation.get("total_passengers", 1)), 1.0)
+    budget_remaining = max(float(observation.get("budget_remaining", 0.0)), 0.0)
+    budget_spent = max(float(observation.get("budget_spent", 0.0)), 0.0)
+    budget_total = max(budget_remaining + budget_spent, 1.0)
+
+    features: List[float] = []
+
+    features.extend(
+        [
+            min(len(pending), 20) / 20.0,
+            min(len(flights), 20) / 20.0,
+            budget_remaining / budget_total,
+            budget_spent / budget_total,
+            processed_count / total_passengers,
+            min(float(observation.get("invalid_actions", 0)), 20.0) / 20.0,
+            min(float(observation.get("step_count", 0)), 120.0) / 120.0,
+            1.0 if pending else 0.0,
+        ]
+    )
+
+    for passenger in pending[:max_pending]:
+        deadline = passenger.get("connection_deadline_hrs")
+        has_deadline = 1.0 if deadline is not None else 0.0
+        deadline_norm = (min(float(deadline), 12.0) / 12.0) if deadline is not None else 1.0
+        features.extend(
+            [
+                _tier_weight(str(passenger.get("priority_tier", ""))) / 4.0,
+                1.0 if passenger.get("cabin_class") == CabinClass.BUSINESS.value else 0.0,
+                has_deadline,
+                deadline_norm,
+            ]
+        )
+
+    for _ in range(max_pending - len(pending[:max_pending])):
+        features.extend([0.0, 0.0, 0.0, 0.0])
+
+    for flight in flights[:max_flights]:
+        features.extend(
+            [
+                1.0 if flight.get("is_partner", False) else 0.0,
+                min(float(flight.get("departure_hrs", 12.0)), 12.0) / 12.0,
+                min(float(flight.get("economy_seats", 0.0)), 12.0) / 12.0,
+                min(float(flight.get("business_seats", 0.0)), 6.0) / 6.0,
+            ]
+        )
+
+    for _ in range(max_flights - len(flights[:max_flights])):
+        features.extend([0.0, 0.0, 0.0, 0.0])
+
+    same_econ = 0.0
+    same_bus = 0.0
+    partner_econ = 0.0
+    partner_bus = 0.0
+    for flight in flights:
+        if flight.get("is_partner", False):
+            partner_econ += float(flight.get("economy_seats", 0.0))
+            partner_bus += float(flight.get("business_seats", 0.0))
+        else:
+            same_econ += float(flight.get("economy_seats", 0.0))
+            same_bus += float(flight.get("business_seats", 0.0))
+
+    features.extend(
+        [
+            min(same_econ, 30.0) / 30.0,
+            min(same_bus, 20.0) / 20.0,
+            min(partner_econ, 30.0) / 30.0,
+            min(partner_bus, 20.0) / 20.0,
+        ]
+    )
+
+    return features
+
+
+def build_feasible_action_for_type(observation: Dict[str, Any], action_type: str) -> Optional[Dict[str, Any]]:
+    pending = _sorted_pending_passengers(observation)
+    flights = _sorted_flights(observation)
+    budget_remaining = float(observation.get("budget_remaining", 0.0))
+
+    if not pending:
+        return {"action_type": ActionType.FINALIZE.value}
+
+    if action_type == ActionType.FINALIZE.value:
+        return None
+
+    if action_type == ActionType.BOOK_HOTEL.value:
+        if budget_remaining >= 250.0:
+            return {
+                "action_type": ActionType.BOOK_HOTEL.value,
+                "passenger_id": pending[0]["id"],
+            }
+        return None
+
+    if action_type == ActionType.MARK_NO_SOLUTION.value:
+        return {
+            "action_type": ActionType.MARK_NO_SOLUTION.value,
+            "passenger_id": pending[0]["id"],
+        }
+
+    if action_type == ActionType.REBOOK_PASSENGER.value:
+        for passenger in pending:
+            for flight in flights:
+                if flight.get("is_partner", False):
+                    continue
+                if _has_seat(flight, str(passenger["cabin_class"])):
+                    return {
+                        "action_type": ActionType.REBOOK_PASSENGER.value,
+                        "passenger_id": passenger["id"],
+                        "flight_id": flight["id"],
+                    }
+        return None
+
+    if action_type == ActionType.OFFER_DOWNGRADE.value:
+        if budget_remaining < 500.0:
+            return None
+        business_pending = [p for p in pending if p.get("cabin_class") == CabinClass.BUSINESS.value]
+        for passenger in business_pending:
+            for flight in flights:
+                if flight.get("is_partner", False):
+                    continue
+                if int(flight.get("economy_seats", 0)) > 0:
+                    return {
+                        "action_type": ActionType.OFFER_DOWNGRADE.value,
+                        "passenger_id": passenger["id"],
+                        "flight_id": flight["id"],
+                    }
+        return None
+
+    if action_type == ActionType.REBOOK_ON_PARTNER.value:
+        if budget_remaining < 800.0:
+            return None
+        for passenger in pending:
+            for flight in flights:
+                if not flight.get("is_partner", False):
+                    continue
+                if _has_seat(flight, str(passenger["cabin_class"])):
+                    return {
+                        "action_type": ActionType.REBOOK_ON_PARTNER.value,
+                        "passenger_id": passenger["id"],
+                        "flight_id": flight["id"],
+                    }
+        return None
+
+    return None
+
+
+def choose_action_from_ranked_types(observation: Dict[str, Any], ranked_types: Iterable[str]) -> Dict[str, Any]:
+    for action_type in ranked_types:
+        if not action_type:
+            continue
+        candidate = build_feasible_action_for_type(observation, str(action_type))
+        if candidate is not None:
+            return candidate
+
+    return heuristic_action(observation)

openenv.yaml

@@ -0,0 +1,42 @@
+name: "flight-rebooking-openenv"
+version: "2.0.0"
+description: "Real-world airline disruption simulator with typed OpenEnv models and deterministic task graders."
+author: "Hackathon Team"
+license: "MIT"
+python_version: "3.10"
+entrypoint: "environment:FlightRebookingEnv"
+
+models:
+  observation: "environment:Observation"
+  action: "environment:Action"
+  reward: "environment:Reward"
+
+api:
+  reset: "FlightRebookingEnv.reset"
+  step: "FlightRebookingEnv.step"
+  state: "FlightRebookingEnv.state"
+
+tasks:
+  - key: "easy"
+    id: "easy_minor_disruption"
+    difficulty: "easy"
+    grader: "tasks:grade_easy_episode"
+    objective: "Rebook all passengers with minimal spend."
+  - key: "medium"
+    id: "medium_connection_crisis"
+    difficulty: "medium"
+    grader: "tasks:grade_medium_episode"
+    objective: "Save urgent connections while honoring tier priority."
+  - key: "hard"
+    id: "hard_multi_wave_disruption"
+    difficulty: "hard"
+    grader: "tasks:grade_hard_episode"
+    objective: "Optimize across loyalty, deadlines, and budget scarcity."
+
+tags:
+  - openenv
+  - airline-operations
+  - decision-making
+  - logistics
+  - reinforcement-learning
+  - huggingface-space

pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "flight-rebooking-agent"
+version = "0.1.0"
+description = "Flight Rebooking OpenEnv Agent"
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi",
+    "uvicorn",
+    "pydantic",
+    "openenv-core>=0.2.0"
+]
+
+[project.scripts]
+server = "server.app:main"

requirements.txt

@@ -0,0 +1,11 @@
+fastapi
+uvicorn
+pydantic
+openai
+torch
+transformers
+peft
+bitsandbytes
+accelerate
+jinja2
+python-multipart

server/app.py

@@ -0,0 +1,16 @@
+import sys
+from pathlib import Path
+
+# Add root dir to path so we can import 'app' and 'environment'
+root_dir = str(Path(__file__).resolve().parent.parent)
+if root_dir not in sys.path:
+    sys.path.insert(0, root_dir)
+
+from app import app
+
+def main():
+    import uvicorn
+    uvicorn.run("app:app", host="0.0.0.0", port=7860)
+
+if __name__ == "__main__":
+    main()

tasks.py

@@ -0,0 +1,481 @@
+"""
+Task Definitions and Deterministic Graders
+===========================================
+
+Provides three progressively difficult real-world disruption tasks and
+task-specific grading functions that return normalized scores in [0.0, 1.0].
+"""
+
+from typing import Dict, List
+
+from environment import EnvState, PassengerStatus, PriorityTier
+
+
+EASY_TASK = {
+    "task_id": "easy_minor_disruption",
+    "difficulty": "easy",
+    "objective": "Rebook all passengers on same-airline flights while preserving premium service and minimizing spend.",
+    "max_budget": 3000,
+    "max_steps": 40,
+    "passengers": [
+        {
+            "id": "P1",
+            "name": "Alice Johnson",
+            "priority_tier": "Platinum",
+            "original_flight": "FL-100",
+            "cabin_class": "Business",
+            "connection_deadline_hrs": None,
+        },
+        {
+            "id": "P2",
+            "name": "Bob Smith",
+            "priority_tier": "Gold",
+            "original_flight": "FL-100",
+            "cabin_class": "Economy",
+            "connection_deadline_hrs": None,
+        },
+        {
+            "id": "P3",
+            "name": "Carol Davis",
+            "priority_tier": "Standard",
+            "original_flight": "FL-100",
+            "cabin_class": "Economy",
+            "connection_deadline_hrs": None,
+        },
+    ],
+    "flights": [
+        {
+            "id": "FL-102",
+            "destination": "New York",
+            "departure_hrs": 3.0,
+            "economy_seats": 5,
+            "business_seats": 2,
+            "is_partner": False,
+        },
+        {
+            "id": "FL-104",
+            "destination": "New York",
+            "departure_hrs": 6.0,
+            "economy_seats": 10,
+            "business_seats": 3,
+            "is_partner": False,
+        },
+        {
+            "id": "FL-201",
+            "destination": "New York",
+            "departure_hrs": 4.0,
+            "economy_seats": 3,
+            "business_seats": 1,
+            "is_partner": True,
+        },
+    ],
+}
+
+
+MEDIUM_TASK = {
+    "task_id": "medium_connection_crisis",
+    "difficulty": "medium",
+    "objective": "Prioritize high-tier passengers with tight deadlines under constrained seats and budget.",
+    "max_budget": 5000,
+    "max_steps": 60,
+    "passengers": [
+        {
+            "id": "P1",
+            "name": "David Lee",
+            "priority_tier": "Platinum",
+            "original_flight": "FL-300",
+            "cabin_class": "Business",
+            "connection_deadline_hrs": 4.0,
+        },
+        {
+            "id": "P2",
+            "name": "Emma Wilson",
+            "priority_tier": "Gold",
+            "original_flight": "FL-300",
+            "cabin_class": "Economy",
+            "connection_deadline_hrs": 2.5,
+        },
+        {
+            "id": "P3",
+            "name": "Frank Brown",
+            "priority_tier": "Silver",
+            "original_flight": "FL-300",
+            "cabin_class": "Economy",
+            "connection_deadline_hrs": None,
+        },
+        {
+            "id": "P4",
+            "name": "Grace Kim",
+            "priority_tier": "Standard",
+            "original_flight": "FL-300",
+            "cabin_class": "Business",
+            "connection_deadline_hrs": 5.0,
+        },
+        {
+            "id": "P5",
+            "name": "Henry Park",
+            "priority_tier": "Gold",
+            "original_flight": "FL-300",
+            "cabin_class": "Economy",
+            "connection_deadline_hrs": 3.0,
+        },
+    ],
+    "flights": [
+        {
+            "id": "FL-302",
+            "destination": "Chicago",
+            "departure_hrs": 2.0,
+            "economy_seats": 2,
+            "business_seats": 1,
+            "is_partner": False,
+        },
+        {
+            "id": "FL-304",
+            "destination": "Chicago",
+            "departure_hrs": 5.0,
+            "economy_seats": 4,
+            "business_seats": 0,
+            "is_partner": False,
+        },
+        {
+            "id": "FL-401",
+            "destination": "Chicago",
+            "departure_hrs": 3.5,
+            "economy_seats": 2,
+            "business_seats": 1,
+            "is_partner": True,
+        },
+    ],
+}
+
+
+HARD_TASK = {
+    "task_id": "hard_multi_wave_disruption",
+    "difficulty": "hard",
+    "objective": "Handle mixed loyalty tiers, scarce seats, and multiple urgent connections while staying under budget.",
+    "max_budget": 7000,
+    "max_steps": 90,
+    "passengers": [
+        {
+            "id": "P1",
+            "name": "Iris Patel",
+            "priority_tier": "Platinum",
+            "original_flight": "FL-500",
+            "cabin_class": "Business",
+            "connection_deadline_hrs": 2.5,
+        },
+        {
+            "id": "P2",
+            "name": "Jack Rivera",
+            "priority_tier": "Gold",
+            "original_flight": "FL-500",
+            "cabin_class": "Economy",
+            "connection_deadline_hrs": 2.0,
+        },
+        {
+            "id": "P3",
+            "name": "Karen Novak",
+            "priority_tier": "Gold",
+            "original_flight": "FL-500",
+            "cabin_class": "Business",
+            "connection_deadline_hrs": 4.0,
+        },
+        {
+            "id": "P4",
+            "name": "Liam Chen",
+            "priority_tier": "Silver",
+            "original_flight": "FL-500",
+            "cabin_class": "Economy",
+            "connection_deadline_hrs": 3.0,
+        },
+        {
+            "id": "P5",
+            "name": "Maya Brooks",
+            "priority_tier": "Standard",
+            "original_flight": "FL-500",
+            "cabin_class": "Economy",
+            "connection_deadline_hrs": None,
+        },
+        {
+            "id": "P6",
+            "name": "Noah Singh",
+            "priority_tier": "Platinum",
+            "original_flight": "FL-500",
+            "cabin_class": "Business",
+            "connection_deadline_hrs": 3.5,
+        },
+        {
+            "id": "P7",
+            "name": "Olivia Green",
+            "priority_tier": "Silver",
+            "original_flight": "FL-500",
+            "cabin_class": "Economy",
+            "connection_deadline_hrs": 5.0,
+        },
+        {
+            "id": "P8",
+            "name": "Peter Hall",
+            "priority_tier": "Standard",
+            "original_flight": "FL-500",
+            "cabin_class": "Economy",
+            "connection_deadline_hrs": 2.8,
+        },
+    ],
+    "flights": [
+        {
+            "id": "FL-502",
+            "destination": "San Francisco",
+            "departure_hrs": 1.8,
+            "economy_seats": 2,
+            "business_seats": 1,
+            "is_partner": False,
+        },
+        {
+            "id": "FL-504",
+            "destination": "San Francisco",
+            "departure_hrs": 3.0,
+            "economy_seats": 2,
+            "business_seats": 1,
+            "is_partner": False,
+        },
+        {
+            "id": "FL-506",
+            "destination": "San Francisco",
+            "departure_hrs": 5.5,
+            "economy_seats": 3,
+            "business_seats": 0,
+            "is_partner": False,
+        },
+        {
+            "id": "FL-701",
+            "destination": "San Francisco",
+            "departure_hrs": 2.2,
+            "economy_seats": 2,
+            "business_seats": 1,
+            "is_partner": True,
+        },
+        {
+            "id": "FL-703",
+            "destination": "San Francisco",
+            "departure_hrs": 4.4,
+            "economy_seats": 2,
+            "business_seats": 1,
+            "is_partner": True,
+        },
+    ],
+}
+
+
+TASKS = {
+    "easy": EASY_TASK,
+    "medium": MEDIUM_TASK,
+    "hard": HARD_TASK,
+}
+
+
+_OUTCOME_SCORES = {
+    PassengerStatus.REBOOKED: 1.00,
+    PassengerStatus.PARTNER_REBOOKED: 0.85,
+    PassengerStatus.DOWNGRADED: 0.65,
+    PassengerStatus.HOTEL_BOOKED: 0.40,
+    PassengerStatus.NO_SOLUTION: 0.00,
+    PassengerStatus.PENDING: 0.00,
+}
+
+
+_TIER_WEIGHTS = {
+    PriorityTier.PLATINUM: 4,
+    PriorityTier.GOLD: 3,
+    PriorityTier.SILVER: 2,
+    PriorityTier.STANDARD: 1,
+}
+
+
+_GRADING_PROFILES = {
+    "easy": {
+        "quality": 0.45,
+        "coverage": 0.20,
+        "connection": 0.10,
+        "budget": 0.15,
+        "policy": 0.10,
+    },
+    "medium": {
+        "quality": 0.38,
+        "coverage": 0.17,
+        "connection": 0.22,
+        "budget": 0.13,
+        "policy": 0.10,
+    },
+    "hard": {
+        "quality": 0.30,
+        "coverage": 0.15,
+        "connection": 0.30,
+        "budget": 0.15,
+        "policy": 0.10,
+    },
+}
+
+
+def _clamp(value: float) -> float:
+    return max(0.01, min(0.99, value))
+
+
+def _resolve_tier_weight(tier: PriorityTier) -> int:
+    if isinstance(tier, str):
+        tier = PriorityTier(tier)
+    return _TIER_WEIGHTS.get(tier, 1)
+
+
+def _resolve_outcome_score(status: PassengerStatus) -> float:
+    if isinstance(status, str):
+        status = PassengerStatus(status)
+    return _OUTCOME_SCORES.get(status, 0.0)
+
+
+def _connection_score(state: EnvState) -> float:
+    deadline_passengers = [p for p in state.passengers if p.connection_deadline_hrs is not None]
+    if not deadline_passengers:
+        return 0.99
+
+    weighted_hits = 0.0
+    weighted_total = 0.0
+
+    flights_by_id = {f.id: f for f in state.flights}
+    for passenger in deadline_passengers:
+        weight = _resolve_tier_weight(passenger.priority_tier)
+        weighted_total += weight
+
+        if passenger.assigned_flight is None:
+            continue
+
+        flight = flights_by_id.get(passenger.assigned_flight)
+        if flight is None:
+            continue
+
+        if flight.departure_hrs <= passenger.connection_deadline_hrs:
+            weighted_hits += weight
+        else:
+            weighted_hits += weight * 0.2
+
+    if weighted_total <= 0:
+        return 0.01
+
+    return _clamp(weighted_hits / weighted_total)
+
+
+def _coverage_score(state: EnvState) -> float:
+    if not state.passengers:
+        return 0.01
+    resolved = sum(1 for p in state.passengers if p.status != PassengerStatus.PENDING)
+    return _clamp(resolved / len(state.passengers))
+
+
+def _quality_score(state: EnvState) -> float:
+    weighted_sum = 0.0
+    weighted_total = 0.0
+
+    for passenger in state.passengers:
+        weight = _resolve_tier_weight(passenger.priority_tier)
+        weighted_total += weight
+        weighted_sum += weight * _resolve_outcome_score(passenger.status)
+
+    if weighted_total <= 0:
+        return 0.01
+
+    return _clamp(weighted_sum / weighted_total)
+
+
+def _budget_score(state: EnvState, max_budget: float) -> float:
+    if max_budget <= 0:
+        return 0.99
+    return _clamp(1.0 - (state.budget_spent / max_budget))
+
+
+def _policy_score(state: EnvState) -> float:
+    invalid_actions = max(getattr(state, "invalid_actions", 0), 0)
+    invalid_penalty = min(invalid_actions * 0.03, 0.3)
+
+    order: Dict[str, int] = {}
+    step = 0
+    for event in state.actions_taken:
+        if not event.get("success", False):
+            continue
+        action = event.get("action", {})
+        passenger_id = action.get("passenger_id")
+        if passenger_id and passenger_id not in order:
+            order[passenger_id] = step
+            step += 1
+
+    inversion_pairs = 0
+    total_pairs = 0
+    passengers = list(state.passengers)
+    for i in range(len(passengers)):
+        for j in range(i + 1, len(passengers)):
+            p_i = passengers[i]
+            p_j = passengers[j]
+            w_i = _resolve_tier_weight(p_i.priority_tier)
+            w_j = _resolve_tier_weight(p_j.priority_tier)
+            if w_i == w_j:
+                continue
+
+            if p_i.id not in order or p_j.id not in order:
+                continue
+
+            total_pairs += 1
+            if w_i > w_j and order[p_i.id] > order[p_j.id]:
+                inversion_pairs += 1
+            if w_j > w_i and order[p_j.id] > order[p_i.id]:
+                inversion_pairs += 1
+
+    inversion_penalty = (inversion_pairs / total_pairs) if total_pairs > 0 else 0.0
+    return _clamp(1.0 - invalid_penalty - inversion_penalty)
+
+
+def _grade_with_profile(state: EnvState, max_budget: float, profile_name: str) -> float:
+    profile = _GRADING_PROFILES[profile_name]
+    quality = _quality_score(state)
+    coverage = _coverage_score(state)
+    connection = _connection_score(state)
+    budget = _budget_score(state, max_budget)
+    policy = _policy_score(state)
+
+    final = (
+        profile["quality"] * quality
+        + profile["coverage"] * coverage
+        + profile["connection"] * connection
+        + profile["budget"] * budget
+        + profile["policy"] * policy
+    )
+    return _clamp(final)
+
+
+def grade_easy_episode(state: EnvState, max_budget: float) -> float:
+    return _grade_with_profile(state, max_budget, "easy")
+
+
+def grade_medium_episode(state: EnvState, max_budget: float) -> float:
+    return _grade_with_profile(state, max_budget, "medium")
+
+
+def grade_hard_episode(state: EnvState, max_budget: float) -> float:
+    return _grade_with_profile(state, max_budget, "hard")
+
+
+TASK_GRADERS = {
+    "easy": grade_easy_episode,
+    "medium": grade_medium_episode,
+    "hard": grade_hard_episode,
+}
+
+
+def grade_task(task_key: str, state: EnvState, max_budget: float) -> float:
+    grader = TASK_GRADERS[task_key]
+    score = grader(state, max_budget)
+    # Enforce strict (0, 1) bounds required by the validator
+    return max(0.01, min(0.99, float(score)))
+
+
+def grade_episode(state: EnvState, max_budget: float) -> float:
+    """Backward-compatible default grader, mapped to medium difficulty."""
+    score = grade_medium_episode(state, max_budget)
+    return max(0.01, min(0.99, float(score)))