Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install git and uv
+RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
+RUN pip install uv
+
+# Copy your environment code
+COPY . /app
+
+# Install dependencies
+RUN uv pip install --system fastapi uvicorn pydantic git+https://github.com/meta-pytorch/OpenEnv.git
+
+# Expose port
+EXPOSE 7860
+
+# Run the server
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,114 @@
 ---
-title: Disruption Env
-emoji: 📉
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 6.3.0
-app_file: app.py
+title: Disruption Recovery RL Environment
+emoji: ✈️🚨
+colorFrom: blue
+colorTo: red
+sdk: docker
+sdk_version: "1.0"
 pinned: false
+tags:
+  - reinforcement-learning
+  - llm-agents
+  - decision-making
+  - simulation
+  - openenv
+  - travel
+  - operations-research
+  - planning
+  - ai-agents
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Disruption Recovery RL Environment
+
+An OpenEnv-compatible reinforcement learning environment for training AI agents to handle travel disruptions. When flights are delayed or cancelled, the agent must rebook connections and adjust ground transportation to minimize cost, delay, and traveler stress.
+
+## Environment Overview
+
+This environment simulates real-world travel disruption scenarios where an agent must:
+- Detect when a flight delay/cancellation breaks downstream bookings
+- Evaluate alternative flight options with time and cost tradeoffs
+- Rebook connections before lock windows expire
+- Adjust cab/transfer timing to match new arrival times
+- Balance competing objectives: minimize delay, cost, and number of changes
+
+## State Space
+
+The agent observes:
+- **Disruption type**: delay or cancellation
+- **Connection status**: buffer time, feasibility, lock-in windows
+- **Alternative flights**: departure/arrival times, costs, availability, buffers
+- **Cab status**: pickup time, mismatch with arrival, cancellation policy
+- **Derived features**: `connection_resolved`, `cab_resolved`, `next_task`
+
+## Action Space
+
+Four actions available:
+1. **`rebook_connection`** — switch to an alternative flight
+2. **`keep_connection`** — maintain current booking
+3. **`cancel_cab_rebook`** — adjust ground transfer timing
+4. **`request_refund`** — cancel and request refund
+
+## Reward Structure
+
+**Terminal rewards:**
+- Success: +100 (reach destination with all bookings resolved)
+- Failure: -200 (missed connection, locked out, or max steps)
+
+**Shaped rewards** (within success):
+- Time penalty: -0.5 per minute of additional delay
+- Cost penalty: -1.0 per currency unit spent
+- Change penalty: -15 per major booking change
+- Stress penalty: -25 for unresolved critical items near lock time
+
+Uses potential-based reward shaping on search space reduction for dense learning signal.
+
+## Usage
+
+### Start the server
+
+The environment runs as a FastAPI server on port 7860:
+
+`uvicorn server.app:app --host 0.0.0.0 --port 7860`
+
+### Interact via HTTP
+
+**Reset:**
+curl -X POST http://localhost:7860/reset
+
+**Step:**
+curl -X POST http://localhost:7860/step
+-H "Content-Type: application/json"
+-d '{"action": {"type": "rebook_connection", "alt_flight_id": "ALT_0"}}'
+
+### Python Client Example
+
+```py
+import httpx from disruption_env.models import DisruptionAction
+
+client = httpx.Client(base_url="http://localhost:7860") 
+obs = client.post("/reset").json()
+
+action = DisruptionAction(type="rebook_connection", alt_flight_id="ALT_0") 
+result = client.post("/step", json={"action": action.dict()}).json()
+
+print(f"Reward: {result['reward']}, Done: {result['done']}")
+```
+
+## Design Features
+
+- **Phase-aware observations**: Clearly signals whether connection or cab needs attention
+- **Feasibility labeling**: Marks invalid options (locked, insufficient buffer) to prevent impossible actions
+- **Temporal constraints**: Lock windows create urgency and force timely decisions
+- **Multi-objective optimization**: Trade off time, cost, and operational complexity
+
+## Competition Context
+
+Built for the **OpenEnv Student Challenge** to demonstrate:
+- Real-world applicability (travel operations)
+- Novel domain (traveler-centric disruption recovery vs airline ops)
+- Rich decision space (temporal constraints, multi-step planning, competing objectives)
+- Production relevance (applicable to travel booking platforms)
+
+## License
+
+BSD-3-Clause (following OpenEnv conventions)

models.py

@@ -0,0 +1,107 @@
+from typing import Optional, Dict, Any, List, Literal
+from dataclasses import dataclass, field
+import time, random, math
+from pydantic import BaseModel, Field
+from openenv.core.env_server import Action, Observation
+
+# ---------- Types ----------
+DisruptionType = Literal["delay", "cancel"]
+ActionType = Literal["rebook_connection", "keep_connection", "cancel_cab_rebook", "request_refund"]
+
+# ---------- Models ----------
+class ObservationFeatures(BaseModel):
+    buffer_min: float
+    flight_lock_in_min: float
+    cab_lock_in_min: float
+    cab_pickup_in_min: float
+    cab_mismatch_min: float  # pickup - arrival - slack
+    connection_resolved: bool
+    cab_resolved: bool
+    next_task: str  # e.g., "FIX_CONNECTION", "FIX_CAB", "DONE"
+
+class AltFlightFeatures(BaseModel):
+    alt_buffer_min: float
+    alt_arrival_delay_min: float
+    alt_lock_in_min: float
+
+class AltFlight(BaseModel):
+    id: str
+    depart_ts: int
+    arrive_ts: int
+    price_delta: float = 0.0
+    reliability: float = 0.8
+    lock_ts: Optional[int] = None
+    features: Optional[AltFlightFeatures] = None
+
+class CabPolicy(BaseModel):
+    cancel_fee: float = 0.0
+    rebook_fee: float = 0.0
+
+class DisruptionAction(Action):
+    type: ActionType
+    alt_flight_id: Optional[str] = None
+    new_cab_pickup_ts: Optional[int] = None
+
+class DisruptionObservation(Observation):
+    now_ts: int
+    at_airport: str
+    orig_conn_depart_ts: int
+    orig_conn_arrive_ts: int
+    disruption_type: DisruptionType
+    delay_minutes: int = 0
+    cancelled: bool = False
+    alt_flights: List[AltFlight] = Field(default_factory=list)
+    cab_pickup_ts: int
+    cab_policy: CabPolicy
+    cab_lock_ts: int
+    flight_lock_ts: int
+    features: Optional[ObservationFeatures] = None
+
+# ---------- Internal State ----------
+@dataclass
+class FlightOption:
+    id: str
+    depart_ts: int
+    arrive_ts: int
+    price_delta: float = 0.0
+    reliability: float = 0.8
+    lock_ts: Optional[int] = None
+
+@dataclass
+class Cab:
+    pickup_ts: int
+    lock_ts: int
+    cancel_fee: float = 0.0
+    rebook_fee: float = 0.0
+    active: bool = True
+    penalties_paid: float = 0.0
+
+@dataclass
+class DisruptionState:
+    seed: int
+    rng: random.Random
+    now_ts: int
+    at_airport: str
+    disruption_type: DisruptionType
+    orig_conn_depart_ts: int
+    orig_conn_arrive_ts: int
+    flight_lock_ts: int
+    planned_gate_ready_ts: int
+    baseline_arrive_ts: int
+    # Fields with defaults below
+    delay_mean_min: float = 0.0
+    delay_std_min: float = 0.0
+    delay_realized_min: Optional[int] = None
+    cancelled: bool = False
+    alt_flights: List[FlightOption] = field(default_factory=list)
+    cab: Cab = None
+    min_connection_buffer_min: int = 45
+    changes: int = 0
+    reversals: int = 0
+    unresolved_critical: int = 0
+    cost_incurred: float = 0.0
+    done: bool = False
+    success: bool = False
+    connection_resolved: bool = False
+    cab_resolved: bool = False
+    fail_reason: Optional[str] = None

server/app.py

@@ -0,0 +1,26 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+from disruption_env.server.disruption_environment import DisruptionEnv
+from disruption_env.models import DisruptionAction
+
+app = FastAPI()
+env = DisruptionEnv(seed=0)
+
+class StepRequest(BaseModel):
+    action: DisruptionAction
+
+@app.post("/reset")
+def reset():
+    obs = env.reset()
+    return obs.model_dump()
+
+@app.post("/step")
+def step(request: StepRequest):
+    obs, reward, done, info = env.step(request.action)
+    return {
+        "observation": obs.model_dump(),
+        "reward": reward,
+        "done": done,
+        "info": info
+    }

server/disruption_environment.py

@@ -0,0 +1,416 @@
+from disruption_env.models import *
+
+class DisruptionEnv:
+    def __init__(self, seed: int = 0, max_steps: int = 6):
+        self.seed = seed
+        self.max_steps = max_steps
+        self._episode_idx = 0
+        self.state: Optional[DisruptionState] = None
+        self.steps = 0
+
+    def _update_resolution_status(self, s: DisruptionState):
+        """Update connection_resolved and cab_resolved flags."""
+        # Connection resolved if buffer sufficient and not cancelled
+        buffer = self._connection_buffer_min(s)
+        s.connection_resolved = (buffer >= s.min_connection_buffer_min and not s.cancelled)
+        
+        # Cab resolved if mismatch within tolerance (0-30 min after arrival)
+        arrival_ts = self._final_arrival_ts(s)
+        cab_mismatch_min = (s.cab.pickup_ts - arrival_ts - 10*60) / 60.0
+        s.cab_resolved = (0 <= cab_mismatch_min <= 30) or not s.cab.active
+
+    def _compute_features(self, s: DisruptionState) -> ObservationFeatures:
+        now = s.now_ts
+        buffer_min = self._connection_buffer_min(s)
+        flight_lock_in_min = (s.flight_lock_ts - now) / 60.0
+        cab_lock_in_min = (s.cab.lock_ts - now) / 60.0
+        
+        arrival_ts = self._final_arrival_ts(s)
+        cab_pickup_in_min = (s.cab.pickup_ts - now) / 60.0
+        cab_mismatch_min = (s.cab.pickup_ts - arrival_ts - 10*60) / 60.0  # 10 min slack
+        
+        if not s.connection_resolved:
+            next_task = "FIX_CONNECTION"
+        elif not s.cab_resolved:
+            next_task = "FIX_CAB"
+        else:
+            next_task = "DONE"
+        
+        return ObservationFeatures(
+            buffer_min=buffer_min,
+            flight_lock_in_min=flight_lock_in_min,
+            cab_lock_in_min=cab_lock_in_min,
+            cab_pickup_in_min=cab_pickup_in_min,
+            cab_mismatch_min=cab_mismatch_min,
+            connection_resolved=s.connection_resolved,
+            cab_resolved=s.cab_resolved,
+            next_task=next_task
+        )
+    
+    def _compute_alt_features(self, s: DisruptionState, alt: FlightOption) -> AltFlightFeatures:
+        now = s.now_ts
+        # Buffer if we switch to this alt
+        gate_ready = self._compute_gate_ready_ts(s)
+        alt_buffer_min = (alt.depart_ts - gate_ready) / 60.0
+        alt_arrival_delay_min = (alt.arrive_ts - s.baseline_arrive_ts) / 60.0
+        alt_lock_in_min = ((alt.lock_ts - now) / 60.0) if alt.lock_ts else 999.0
+        
+        return AltFlightFeatures(
+            alt_buffer_min=alt_buffer_min,
+            alt_arrival_delay_min=alt_arrival_delay_min,
+            alt_lock_in_min=alt_lock_in_min
+        )
+
+
+    # ---------- Timing Helpers ----------
+    def _compute_gate_ready_ts(self, s: DisruptionState) -> int:
+        t = s.planned_gate_ready_ts
+        if s.disruption_type == "cancel" and s.cancelled:
+            return t  # cancellation handled elsewhere
+        if s.disruption_type == "delay":
+            t += int(round(s.delay_mean_min)) * 60
+        return t
+
+    def _connection_buffer_min(self, s: DisruptionState) -> float:
+        gate_ready = self._compute_gate_ready_ts(s)
+        return (s.orig_conn_depart_ts - gate_ready) / 60.0
+
+    def _final_arrival_ts(self, s: DisruptionState) -> int:
+        t = s.orig_conn_arrive_ts
+        if s.disruption_type == "delay":
+            t += int(round(s.delay_mean_min)) * 60
+        return t
+
+    def _delta_delay_min(self, s: DisruptionState) -> float:
+        return (self._final_arrival_ts(s) - s.baseline_arrive_ts) / 60.0
+
+    # ---------- Terminal Resolution ----------
+    def _resolve_terminal(self, s: DisruptionState):
+        print(f"DEBUG: Entering _resolve_terminal, unresolved_critical={s.unresolved_critical}")
+
+        # Cancellation unresolved past lock
+        if s.now_ts >= s.flight_lock_ts and s.disruption_type == "cancel" and s.cancelled:
+            s.done = True
+            s.success = False
+            s.fail_reason = "flight_cancelled_unresolved"
+            return
+
+        # Cancellation still active
+        if s.disruption_type == "cancel" and s.cancelled:
+            s.done = True
+            s.success = False
+            s.fail_reason = "cancelled_connection"
+            return
+
+        # Buffer check for delay
+        buf = self._connection_buffer_min(s)
+        if buf < s.min_connection_buffer_min:
+            s.done = True
+            s.success = False
+            s.fail_reason = "missed_connection"
+            return
+
+        # Cab feasibility
+        arrival_ts = self._final_arrival_ts(s)
+        if s.cab.active and s.cab.pickup_ts < arrival_ts + 10 * 60:
+            if s.now_ts >= s.cab.lock_ts:
+                s.done = True
+                s.success = False
+                s.fail_reason = "cab_missed_locked"
+                return
+            else:
+                s.unresolved_critical = 1
+
+        print(f"DEBUG: Before success check - unresolved={s.unresolved_critical}, cancelled={s.cancelled}")
+
+        # Success if no unresolved issues
+        if s.connection_resolved and s.cab_resolved and s.unresolved_critical == 0:
+            print("DEBUG: Setting success=True")
+            s.done = True
+            s.success = True
+            s.fail_reason = None
+
+    # ---------- Reward ----------
+    def _reward(self, s: DisruptionState) -> float:
+        if s.done and s.success:
+            dT = max(0.0, self._delta_delay_min(s))
+            return 100.0 - 0.5 * dT - 1.0 * s.cost_incurred - 15.0 * s.changes - 25.0 * s.unresolved_critical
+        if s.done and not s.success:
+            return -200.0
+        return -0.2  # step penalty
+
+    # ---------- Observation Projection ----------
+    def _obs_from_state(self, s: DisruptionState) -> DisruptionObservation:
+        delay_minutes = int(round(s.delay_mean_min)) if s.disruption_type == "delay" else 0
+        
+        # Compute features for alt flights
+        alt = []
+        for f in s.alt_flights:
+            alt_features = self._compute_alt_features(s, f)
+            alt.append(AltFlight(
+                id=f.id, depart_ts=f.depart_ts, arrive_ts=f.arrive_ts,
+                price_delta=f.price_delta, reliability=f.reliability, lock_ts=f.lock_ts,
+                features=alt_features
+            ))
+        
+        # Compute main features
+        features = self._compute_features(s)
+        
+        return DisruptionObservation(
+            now_ts=s.now_ts,
+            at_airport=s.at_airport,
+            orig_conn_depart_ts=s.orig_conn_depart_ts,
+            orig_conn_arrive_ts=s.orig_conn_arrive_ts,
+            disruption_type=s.disruption_type,
+            delay_minutes=delay_minutes,
+            cancelled=s.cancelled,
+            alt_flights=alt,
+            cab_pickup_ts=s.cab.pickup_ts,
+            cab_policy=CabPolicy(cancel_fee=s.cab.cancel_fee, rebook_fee=s.cab.rebook_fee),
+            cab_lock_ts=s.cab.lock_ts,
+            flight_lock_ts=s.flight_lock_ts,
+            features=features
+        )
+
+    # ---------- Reset ----------
+    def reset(self, *, seed: Optional[int] = None) -> DisruptionObservation:
+        if seed is None:
+            seed = self.seed + self._episode_idx
+        rng = random.Random(seed)
+        self._episode_idx += 1
+        self.steps = 0
+
+        now_ts = int(time.time())
+        at_airport = "ORIGIN"
+
+        orig_conn_depart_ts = now_ts + 3 * 3600
+        orig_conn_arrive_ts = now_ts + 7 * 3600
+        baseline_arrive_ts = orig_conn_arrive_ts
+
+        # Gate ready with buffer
+        base_buffer_min = rng.choice([35, 50, 70, 90])
+        planned_gate_ready_ts = orig_conn_depart_ts - base_buffer_min * 60
+
+        disruption_type: DisruptionType = rng.choice(["delay", "cancel"])
+        cancelled = (disruption_type == "cancel")
+
+        if disruption_type == "delay":
+            delay_mean_min = rng.choice([15, 45, 90, 180])
+            delay_std_min = 0.0
+        else:
+            delay_mean_min = 0.0
+            delay_std_min = 0.0
+
+        flight_lock_ts = now_ts + rng.choice([20, 40, 90]) * 60
+        cab_lock_ts = now_ts + rng.choice([20, 60, 120]) * 60
+
+        cab = Cab(
+            pickup_ts=orig_conn_arrive_ts + 20 * 60,
+            lock_ts=cab_lock_ts,
+            cancel_fee=rng.choice([0.0, 10.0, 25.0]),
+            rebook_fee=rng.choice([0.0, 5.0, 15.0]),
+            active=True,
+            penalties_paid=0.0,
+        )
+
+        alt_flights: List[FlightOption] = []
+        for i in range(rng.randint(1, 4)):
+            depart = orig_conn_depart_ts + rng.choice([-60, 0, 60, 120, 240]) * 60
+            arrive = orig_conn_arrive_ts + rng.choice([0, 30, 60, 120, 240]) * 60
+            alt_flights.append(FlightOption(
+                id=f"ALT_{i}",
+                depart_ts=depart,
+                arrive_ts=arrive,
+                price_delta=rng.choice([0.0, 25.0, 60.0, 120.0]),
+                reliability=rng.choice([0.6, 0.75, 0.9]),
+                lock_ts=now_ts + rng.choice([15, 30, 60]) * 60
+            ))
+
+        self.state = DisruptionState(
+            seed=seed, rng=rng,
+            now_ts=now_ts, at_airport=at_airport,
+            disruption_type=disruption_type,
+            delay_mean_min=delay_mean_min, delay_std_min=delay_std_min,
+            delay_realized_min=None,
+            cancelled=cancelled,
+            orig_conn_depart_ts=orig_conn_depart_ts,
+            orig_conn_arrive_ts=orig_conn_arrive_ts,
+            flight_lock_ts=flight_lock_ts,
+            alt_flights=alt_flights,
+            cab=cab,
+            planned_gate_ready_ts=planned_gate_ready_ts,
+            baseline_arrive_ts=baseline_arrive_ts,
+            min_connection_buffer_min=45,
+            changes=0, reversals=0, unresolved_critical=0, cost_incurred=0.0,
+            done=False, success=False, fail_reason=None,
+        )
+        return self._obs_from_state(self.state)
+
+    # ---------- Step ----------
+    def step(self, action: DisruptionAction):
+        s = self.state
+        if s is None:
+            raise RuntimeError("Call reset() before step().")
+        if s.done:
+            return self._obs_from_state(s), 0.0, True, {"fail_reason": s.fail_reason, "success": s.success}
+
+        self.steps += 1
+        now = s.now_ts
+
+        # Apply action
+        if action.type == "rebook_connection":
+            if now >= s.flight_lock_ts:
+                s.done = True; s.success = False; s.fail_reason = "flight_locked"
+            elif not action.alt_flight_id:
+                s.done = True; s.success = False; s.fail_reason = "missing_alt_flight_id"
+            else:
+                chosen = next((f for f in s.alt_flights if f.id == action.alt_flight_id), None)
+                if chosen is None:
+                    s.done = True; s.success = False; s.fail_reason = "unknown_alt_flight"
+                elif chosen.lock_ts is not None and now >= chosen.lock_ts:
+                    s.done = True; s.success = False; s.fail_reason = "alt_flight_locked"
+                else:
+                    s.changes += 1
+                    s.cost_incurred += chosen.price_delta
+                    s.orig_conn_depart_ts = chosen.depart_ts
+                    s.orig_conn_arrive_ts = chosen.arrive_ts
+                    s.cancelled = False  # Resolve cancellation
+
+
+        elif action.type == "keep_connection":
+            pass  # No change, feasibility checked in _resolve_terminal
+
+        elif action.type == "cancel_cab_rebook":
+            if now >= s.cab.lock_ts:
+                s.done = True; s.success = False; s.fail_reason = "cab_locked"
+            elif action.new_cab_pickup_ts is None:
+                s.done = True; s.success = False; s.fail_reason = "missing_new_cab_pickup_ts"
+            else:
+                s.changes += 1
+                s.cost_incurred += s.cab.rebook_fee
+                s.cab.pickup_ts = action.new_cab_pickup_ts
+                # Clear unresolved if cab timing is now valid
+                s.unresolved_critical = 0
+
+        elif action.type == "request_refund":
+            s.changes += 1
+
+        else:
+            s.done = True; s.success = False; s.fail_reason = "unknown_action"
+
+        # Advance time
+        s.now_ts += 5 * 60
+
+        # Check terminal conditions if not already failed
+        if not s.done:
+            self._update_resolution_status(s)
+            self._resolve_terminal(s)
+
+        # Max steps fallback
+        if not s.done and self.steps >= self.max_steps:
+            s.done = True
+            s.success = False
+            s.fail_reason = "max_steps"
+
+        reward = self._reward(s)
+        info = {
+            "success": s.success,
+            "fail_reason": s.fail_reason,
+            "cost_incurred": s.cost_incurred,
+            "changes": s.changes,
+            "delta_delay_min": self._delta_delay_min(s) if s.success else None
+        }
+        return self._obs_from_state(s), reward, s.done, info
+    
+
+def format_observation_for_llm(obs: DisruptionObservation) -> str:
+    f = obs.features
+    min_buffer = 45
+    
+    # Phase-aware header
+    if f.connection_resolved and f.cab_resolved:
+        status_header = "=== STATUS: ALL RESOLVED ==="
+    elif f.connection_resolved:
+        status_header = "=== STATUS: CONNECTION RESOLVED, CAB NEEDS ATTENTION ==="
+    else:
+        status_header = "=== STATUS: CONNECTION UNRESOLVED ==="
+    
+    # Build prompt based on phase
+    prompt = f"""{status_header}
+Next task: {f.next_task}
+
+=== SITUATION ===
+Disruption: {obs.disruption_type}
+"""
+    
+    # Connection section
+    if f.connection_resolved:
+        prompt += f"Connection: RESOLVED (buffer {f.buffer_min:.0f} min)\n"
+    else:
+        feasible = f.buffer_min >= min_buffer and not obs.cancelled
+        prompt += f"Original plan feasible: {'YES' if feasible else 'NO'}\n"
+        if obs.cancelled:
+            prompt += "Hard constraint: keep_connection will FAIL (flight cancelled)\n"
+        elif f.buffer_min < min_buffer:
+            prompt += f"Hard constraint: keep_connection will FAIL (buffer {f.buffer_min:.0f} min < {min_buffer} min required)\n"
+        prompt += f"Required min buffer: {min_buffer} min\n"
+    
+    # Urgency
+    alt_locks = [alt.features.alt_lock_in_min for alt in obs.alt_flights if alt.features]
+    min_alt_lock = min(alt_locks) if alt_locks else 999
+    prompt += f"""
+=== URGENCY ===
+Next lock: {min(min_alt_lock, f.flight_lock_in_min, f.cab_lock_in_min):.0f} min
+Flight lock: {f.flight_lock_in_min:.0f} min
+Cab lock: {f.cab_lock_in_min:.0f} min
+"""
+    
+    # Cab section (emphasize if that's the task)
+    cab_status = "OK" if f.cab_resolved else ("too early" if f.cab_mismatch_min < 0 else "too late")
+    prompt += f"""
+=== CAB STATUS ===
+Cab pickup mismatch: {f.cab_mismatch_min:+.0f} min ({cab_status})
+"""
+    if not f.cab_resolved:
+        prompt += f"** ACTION REQUIRED: Rebook cab to align with arrival **\n"
+    
+    # Options section (only if connection not resolved)
+    if not f.connection_resolved:
+        options_lines = []
+        for alt in obs.alt_flights:
+            af = alt.features
+            if af.alt_lock_in_min <= 0:
+                feasible_label = "INVALID"
+                reason = "locked"
+            elif af.alt_buffer_min < min_buffer:
+                feasible_label = "INVALID"
+                reason = f"buffer {af.alt_buffer_min:.0f} < {min_buffer}"
+            else:
+                feasible_label = "FEASIBLE"
+                reason = ""
+            
+            reason_str = f" ({reason})" if reason else ""
+            options_lines.append(
+                f"{alt.id}: [{feasible_label}{reason_str}] buffer={af.alt_buffer_min:+.0f}, "
+                f"delay={af.alt_arrival_delay_min:+.0f}, cost={alt.price_delta:+.0f}, locks_in={af.alt_lock_in_min:.0f}"
+            )
+        
+        prompt += f"""
+=== FLIGHT OPTIONS ===
+{chr(10).join(options_lines)}
+"""
+    
+    # Action instructions
+    prompt += """
+=== ACTION (strict) ===
+Only choose FEASIBLE options!
+Respond exactly:
+rebook_connection | alt_flight_id=ALT_X
+OR
+cancel_cab_rebook | new_cab_pickup_in_min=X
+OR
+keep_connection |
+OR
+request_refund |
+"""
+    return prompt