Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=hack_meta
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -1,10 +1,180 @@
 ---
-title: Hack Meta
-emoji: 🌖
-colorFrom: indigo
-colorTo: gray
+title: Disaster Response Coordination Environment
+emoji: 🚨
+colorFrom: red
+colorTo: yellow
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Disaster Response Coordination Environment
+
+This OpenEnv environment simulates an Emergency Operations Center allocating scarce resources across simultaneous disaster targets. The agent must reduce preventable deaths, critical injuries, exposure harm, and infrastructure failure across a ladder of progressively harder scenes.
+
+## Motivation
+
+This is a real-world coordination problem rather than a toy task. It evaluates whether an agent can:
+
+- prioritize under time pressure
+- reason about vulnerability and deadlines
+- handle mixed rescue and infrastructure triage
+- avoid harmful but superficially plausible actions
+
+The environment is designed to provide rich per-step reward while keeping the true harm model hidden from the agent.
+
+## Action Space
+
+Each turn the agent submits a `DisasterAction` with zero or more resource assignments:
+
+```json
+{
+  "assignments": [
+    {"resource_id": "engineering_strike", "target_id": "hospital_power"},
+    {"resource_id": "tunnel_rescue", "target_id": "tunnel_train"}
+  ]
+}
+```
+
+Constraints:
+
+- a resource may be assigned at most once per turn
+- unavailable resources must not be assigned
+- resolved or failed targets should not be assigned
+- assignments with no capability overlap are ineffective and penalized
+
+## Observation Space
+
+The agent sees:
+
+- scene id, name, and level
+- narrative briefing
+- visible target state:
+  - status
+  - estimated people
+  - observed risk
+  - `critical_now`
+  - `priority_band`
+  - vulnerability label
+  - progress
+  - time remaining
+  - recommended capabilities
+- visible resource state:
+  - capabilities
+  - availability
+  - remaining uses
+  - available-until turn
+- structured feedback from the previous step
+
+The latent harm model remains hidden so the policy cannot self-score.
+
+## Task Ladder
+
+The environment contains a genuine easy-to-hard difficulty range:
+
+1. `scene_1`: Flash Flood, Two Rescue Calls, One Boat
+2. `scene_2`: Flood Rescue vs Medical Transport
+3. `scene_3`: Building Collapse vs Highway Hazmat Crash
+4. `scene_4`: Wildfire Suburb vs Nursing Home
+5. `scene_5`: Hospital Backup Power vs Tunnel Train Entrapment
+6. `scene_6`: Toxic Plume vs Downtown Office Tower Fire
+7. `scene_7`: Bridge Collapse During VIP Event Weekend
+8. `scene_8`: Regional Multi-Disaster with Scarce Air Assets
+
+For submission purposes, this exceeds the minimum requirement of three tasks with easy, medium, and hard coverage.
+
+## Reward And Grading
+
+Per-step reward is dense and shaped:
+
+- positive reward for reducing latent remaining harm
+- penalties for invalid actions
+- penalties for ineffective assignments
+- penalties for leaving compatible resources idle during critical windows
+- penalties for deadline misses, churn, and failed targets
+
+Final evaluation uses a normalized score against a no-op baseline:
+
+- `final_score` in `[0, 100]`
+- `grader_score = final_score / 100.0` in `[0.0, 1.0]`
+
+This keeps grading deterministic and reproducible while preserving a meaningful learning signal.
+
+## Baselines
+
+The repo-root [`inference.py`](/c:/Users/pavan/meta-pytorch-hackathon/inference.py) supports:
+
+- `heuristic`
+- `random`
+- `llm`
+
+Recent observed behavior:
+
+- strong scenes: `scene_4`, `scene_6`, `scene_7`
+- middling scenes: `scene_2`, `scene_5`
+- weak scenes: `scene_1`, `scene_3`
+- hard-fail scene: `scene_8`
+
+## Validate Locally
+
+From this directory:
+
+```powershell
+.\.venv\Scripts\openenv.exe validate
+```
+
+## Run Locally
+
+Run the API locally:
+
+```powershell
+.\.venv\Scripts\python.exe -m server.app
+```
+
+Or:
+
+```powershell
+uvicorn server.app:app --host 0.0.0.0 --port 8000
+```
+
+## Docker
+
+Build from this directory:
+
+```powershell
+docker build -t hack_meta-env:latest -f server/Dockerfile .
+```
+
+Run:
+
+```powershell
+docker run --rm -p 8000:8000 hack_meta-env:latest
+```
+
+## Hugging Face Space
+
+This package directory is the deployable environment root. Deploy from `hack_meta/`, not from the repo root.
+
+Before pushing:
+
+1. configure environment secrets in the Space settings
+2. validate locally
+3. confirm `reset()` responds successfully
+
+## Package Layout
+
+```text
+hack_meta/
+|-- client.py
+|-- models.py
+|-- openenv.yaml
+|-- pyproject.toml
+|-- README.md
+`-- server/
+    |-- app.py
+    |-- Dockerfile
+    `-- hack_meta_environment.py
+```

__init__.py

@@ -0,0 +1,25 @@
+"""Disaster response scene ladder package exports."""
+
+from .models import (
+    DisasterAction,
+    DisasterObservation,
+    DisasterReward,
+    ResourceAssignment,
+    ResourceStatus,
+    TargetStatus,
+)
+
+try:
+    from .client import DisasterResponseEnv
+except ImportError:  # pragma: no cover
+    DisasterResponseEnv = None  # type: ignore[assignment]
+
+__all__ = [
+    "DisasterAction",
+    "DisasterObservation",
+    "DisasterReward",
+    "ResourceAssignment",
+    "ResourceStatus",
+    "TargetStatus",
+    "DisasterResponseEnv",
+]

client.py

@@ -0,0 +1,73 @@
+"""Disaster response scene ladder client."""
+
+from typing import Dict
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from .models import (
+    DisasterAction,
+    DisasterObservation,
+    ResourceStatus,
+    TargetStatus,
+)
+
+
+class DisasterResponseEnv(EnvClient[DisasterAction, DisasterObservation, State]):
+    """Client for the scene-based disaster response environment."""
+
+    def _step_payload(self, action: DisasterAction) -> Dict:
+        return {
+            "assignments": [
+                {
+                    "resource_id": assignment.resource_id,
+                    "target_id": assignment.target_id,
+                }
+                for assignment in action.assignments
+            ]
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[DisasterObservation]:
+        obs_data = payload.get("observation", {})
+
+        targets = {
+            target_id: TargetStatus(**target_data)
+            for target_id, target_data in obs_data.get("targets", {}).items()
+        }
+        resources = {
+            resource_id: ResourceStatus(**resource_data)
+            for resource_id, resource_data in obs_data.get("resources", {}).items()
+        }
+
+        observation = DisasterObservation(
+            scene_id=obs_data.get("scene_id", ""),
+            scene_name=obs_data.get("scene_name", ""),
+            level=obs_data.get("level", 0),
+            narrative=obs_data.get("narrative", ""),
+            targets=targets,
+            resources=resources,
+            resolved_count=obs_data.get("resolved_count", 0),
+            turn=obs_data.get("turn", 0),
+            max_turns=obs_data.get("max_turns", 0),
+            feedback=obs_data.get("feedback", ""),
+            final_score=obs_data.get("final_score"),
+            done=payload.get("done", False),
+            reward=payload.get("reward", 0.0),
+            metadata=obs_data.get("metadata", {}),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+            scene_id=payload.get("scene_id"),
+            scene_name=payload.get("scene_name"),
+            level=payload.get("level"),
+        )

models.py

@@ -0,0 +1,171 @@
+"""
+Data models for the scene-based disaster response environment.
+"""
+
+from typing import Dict, List, Optional
+
+from openenv.core.env_server.types import Action, Observation
+from pydantic import BaseModel, Field
+
+
+class ResourceAssignment(BaseModel):
+    """Assign one resource to one target for the current turn."""
+
+    resource_id: str = Field(..., description="Resource to deploy this turn")
+    target_id: str = Field(..., description="Target to support this turn")
+
+
+class DisasterAction(Action):
+    """
+    Action for the disaster response ladder.
+
+    Each turn the agent assigns scarce resources to targets. A resource may only
+    appear once in the action list for the turn.
+    """
+
+    assignments: List[ResourceAssignment] = Field(
+        default_factory=list,
+        description=(
+            "Per-turn resource assignments. Each item maps one resource_id to "
+            "one target_id. Resources not listed remain idle."
+        ),
+    )
+
+
+class ResourceStatus(BaseModel):
+    """Visible status for a deployable resource."""
+
+    name: str = Field(..., description="Human-readable resource name")
+    capabilities: List[str] = Field(
+        default_factory=list,
+        description="Operational capabilities this resource can provide",
+    )
+    available: bool = Field(..., description="Whether the resource can be deployed")
+    remaining_uses: Optional[int] = Field(
+        default=None,
+        description="How many episode-wide uses remain, if finite",
+    )
+    available_until_turn: Optional[int] = Field(
+        default=None,
+        description="Last turn on which the resource can still be used, if limited",
+    )
+    description: str = Field(..., description="Operational description")
+
+
+class TargetStatus(BaseModel):
+    """Visible status for a response target within the current scene."""
+
+    name: str = Field(..., description="Human-readable target name")
+    category: str = Field(..., description="Target category such as victims or infrastructure")
+    status: str = Field(
+        ...,
+        description="One of: active, contained, resolved, or failed",
+    )
+    estimated_people: str = Field(
+        ...,
+        description="Visible people estimate or affected population note",
+    )
+    observed_risk: float = Field(
+        ...,
+        description="Observed urgency signal in the range 0.0 to 1.0",
+    )
+    critical_now: bool = Field(
+        ...,
+        description="Whether this target is in an immediate decision window",
+    )
+    priority_band: str = Field(
+        ...,
+        description="Model-facing priority label: immediate, high, medium, monitor, or failed",
+    )
+    vulnerability: str = Field(
+        ...,
+        description="Visible vulnerability band for the target population",
+    )
+    visibility: float = Field(
+        ...,
+        description="How visible the incident is publicly, 0.0 to 1.0",
+    )
+    progress: float = Field(
+        ...,
+        description="Mitigation progress from 0.0 to 1.0",
+    )
+    time_remaining: int = Field(
+        ...,
+        description="Approximate turns before the target becomes much harder to save",
+    )
+    recommended_capabilities: List[str] = Field(
+        default_factory=list,
+        description="Capabilities that can materially improve the target",
+    )
+    last_assigned_resources: List[str] = Field(
+        default_factory=list,
+        description="Resources deployed to this target on the previous turn",
+    )
+    description: str = Field(..., description="Operational context and constraints")
+
+
+class DisasterObservation(Observation):
+    """
+    Observation returned after each turn of the scene ladder.
+
+    The simulator exposes the operational picture but keeps the full latent harm
+    model internal so rewards cannot be self-scored by the agent.
+    """
+
+    scene_id: str = Field(..., description="Stable scene identifier")
+    scene_name: str = Field(..., description="Human-readable scene name")
+    level: int = Field(..., description="Difficulty level for the scene")
+    narrative: str = Field(..., description="Top-level scene briefing")
+    targets: Dict[str, TargetStatus] = Field(
+        default_factory=dict,
+        description="Visible target statuses keyed by target ID",
+    )
+    resources: Dict[str, ResourceStatus] = Field(
+        default_factory=dict,
+        description="Deployable resource statuses keyed by resource ID",
+    )
+    resolved_count: int = Field(
+        default=0,
+        description="Number of targets resolved so far",
+    )
+    turn: int = Field(default=0, description="Current turn number")
+    max_turns: int = Field(default=0, description="Maximum turns in the scene")
+    feedback: str = Field(
+        default="",
+        description="Structured feedback on the last action and simulator update",
+    )
+    final_score: Optional[float] = Field(
+        default=None,
+        description="Normalized 0-100 score once the episode is complete",
+    )
+
+
+class DisasterReward(BaseModel):
+    """
+    Typed reward model for the disaster response ladder.
+
+    OpenEnv responses still carry the scalar reward at step time, but this model
+    makes the reward contract explicit for spec compliance and documentation.
+    """
+
+    value: float = Field(..., description="Scalar step reward returned by the environment")
+    final_score: Optional[float] = Field(
+        default=None,
+        description="Normalized 0-100 end-of-episode score when available",
+    )
+    fatalities: Optional[float] = Field(
+        default=None,
+        description="Cumulative fatalities observed in audit metrics, if available",
+    )
+    critical_injuries: Optional[float] = Field(
+        default=None,
+        description="Cumulative critical injuries observed in audit metrics, if available",
+    )
+    deadline_misses: Optional[float] = Field(
+        default=None,
+        description="Weighted count of missed critical windows, if available",
+    )
+    failed_targets: Optional[float] = Field(
+        default=None,
+        description="Weighted count of targets that reached failed status, if available",
+    )

openenv.yaml

@@ -0,0 +1,7 @@
+spec_version: 1
+name: hack_meta
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+

openenv_hack_meta.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: openenv-hack_meta
+Version: 0.1.0
+Summary: Disaster Response Coordination Environment for OpenEnv — EOC agent allocates teams across simultaneous incidents to minimise casualties
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.2
+Requires-Dist: python-dotenv>=1.2.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_hack_meta.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+__init__.py
+client.py
+models.py
+pyproject.toml
+./__init__.py
+./client.py
+./models.py
+openenv_hack_meta.egg-info/PKG-INFO
+openenv_hack_meta.egg-info/SOURCES.txt
+openenv_hack_meta.egg-info/dependency_links.txt
+openenv_hack_meta.egg-info/entry_points.txt
+openenv_hack_meta.egg-info/requires.txt
+openenv_hack_meta.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/hack_meta_environment.py

openenv_hack_meta.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_hack_meta.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = hack_meta.server.app:main

openenv_hack_meta.egg-info/requires.txt

@@ -0,0 +1,6 @@
+openenv-core[core]>=0.2.2
+python-dotenv>=1.2.2
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_hack_meta.egg-info/top_level.txt

@@ -0,0 +1 @@
+hack_meta

pyproject.toml

@@ -0,0 +1,46 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-hack_meta"
+version = "0.1.0"
+description = "Disaster Response Coordination Environment for OpenEnv — EOC agent allocates teams across simultaneous incidents to minimise casualties"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]>=0.2.2",
+    # Environment-specific dependencies
+    # Add all dependencies needed for your environment here
+    # Examples:
+    # "numpy>=1.19.0",
+    # "torch>=2.0.0",
+    # "gymnasium>=0.29.0",
+    # "openspiel>=1.0.0",
+    # "smolagents>=1.22.0,<2",
+    "python-dotenv>=1.2.2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m hack_meta.server.app
+server = "hack_meta.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["hack_meta", "hack_meta.server"]
+package-dir = { "hack_meta" = ".", "hack_meta.server" = "server" }

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Disaster Response Coordination environment server components."""
+
+from .hack_meta_environment import DisasterResponseEnvironment
+
+__all__ = ["DisasterResponseEnvironment"]

server/app.py

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Hack Meta Environment.
+
+This module creates an HTTP server that exposes the HackMetaEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+try:
+    from ..models import DisasterAction, DisasterObservation
+    from .hack_meta_environment import DisasterResponseEnvironment
+except ImportError:
+    from models import DisasterAction, DisasterObservation
+    from server.hack_meta_environment import DisasterResponseEnvironment
+
+
+# Create the app with web interface and README integration
+app = create_app(
+    DisasterResponseEnvironment,
+    DisasterAction,
+    DisasterObservation,
+    env_name="disaster_response",
+    max_concurrent_envs=10,  # supports concurrent WebSocket sessions
+)
+
+
+def main() -> None:
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        uv run --project . server --port 8001
+        python -m hack_meta.server.app
+
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn hack_meta.server.app:app --workers 4
+    """
+    import argparse
+    import uvicorn
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+
+    uvicorn.run(app, host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

server/hack_meta_environment.py

@@ -0,0 +1,601 @@
+"""
+Scene-based disaster response coordination environment.
+"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any, Dict, List, Optional
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+try:
+    from ..models import (
+        DisasterAction,
+        DisasterObservation,
+        ResourceStatus,
+        TargetStatus,
+    )
+    from .scene_catalog import DEFAULT_SCENE_ID, SCENE_CATALOG, SceneConfig, ordered_scene_ids
+except ImportError:
+    from models import DisasterAction, DisasterObservation, ResourceStatus, TargetStatus
+    from server.scene_catalog import DEFAULT_SCENE_ID, SCENE_CATALOG, SceneConfig, ordered_scene_ids
+
+
+class DisasterResponseEnvironment(Environment):
+    """
+    Multi-scene disaster response environment with hidden-state reward shaping.
+
+    The agent sees targets, resources, and timing cues, but rewards come from a
+    latent harm model so the policy cannot self-certify mediocre behavior.
+    """
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self) -> None:
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._scene: SceneConfig = SCENE_CATALOG[DEFAULT_SCENE_ID]
+        self._targets: Dict[str, Dict[str, Any]] = {}
+        self._resources: Dict[str, Dict[str, Any]] = {}
+        self._metrics: Dict[str, float] = {}
+        self._turn: int = 0
+        self._baseline_harm: float = 0.0
+        self._final_score: Optional[float] = None
+
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        scene_id: Optional[str] = None,
+        level: Optional[int] = None,
+        **kwargs: Any,
+    ) -> DisasterObservation:
+        self._state = State(
+            episode_id=episode_id or str(uuid4()),
+            step_count=0,
+        )
+        self._scene = self._select_scene(scene_id=scene_id, level=level)
+        self._targets = self._init_targets(self._scene)
+        self._resources = self._init_resources(self._scene)
+        self._metrics = {
+            "fatalities": 0.0,
+            "critical_injuries": 0.0,
+            "exposure_harm": 0.0,
+            "service_loss": 0.0,
+            "invalid_actions": 0.0,
+            "ineffective_assignments": 0.0,
+            "deadline_misses": 0.0,
+            "reassignment_churn": 0.0,
+            "resolved_targets": 0.0,
+            "failed_targets": 0.0,
+        }
+        self._turn = 0
+        self._final_score = None
+        self._baseline_harm = self._simulate_noop_baseline()
+
+        feedback = (
+            f"Level {self._scene.level}: {self._scene.name}\n"
+            f"{self._scene.briefing}\n"
+            f"Why this is hard: {self._scene.why_harder}\n"
+            "Objective: minimize preventable deaths, critical injuries, exposure, and service collapse.\n"
+            "Submit assignments as a JSON list of {resource_id, target_id} objects."
+        )
+        return self._build_observation(feedback=feedback, reward=0.0, done=False)
+
+    def step(self, action: DisasterAction, **kwargs: Any) -> DisasterObservation:  # type: ignore[override]
+        self._turn += 1
+        self._state.step_count += 1
+
+        feedback_parts: List[str] = []
+        prev_potential = self._potential(self._targets)
+
+        assignments_by_target: Dict[str, List[str]] = {tid: [] for tid in self._targets}
+        used_resources: set[str] = set()
+        penalty = 0.0
+
+        for assignment in action.assignments:
+            resource_id = assignment.resource_id
+            target_id = assignment.target_id
+
+            if resource_id not in self._resources:
+                penalty += 6.0
+                self._metrics["invalid_actions"] += 1
+                feedback_parts.append(f"[ERR] Unknown resource '{resource_id}'")
+                continue
+            if target_id not in self._targets:
+                penalty += 6.0
+                self._metrics["invalid_actions"] += 1
+                feedback_parts.append(f"[ERR] Unknown target '{target_id}'")
+                continue
+            if resource_id in used_resources:
+                penalty += 5.0
+                self._metrics["invalid_actions"] += 1
+                feedback_parts.append(f"[ERR] Resource '{resource_id}' assigned more than once")
+                continue
+            if not self._resource_available(self._resources[resource_id], self._turn):
+                penalty += 5.0
+                self._metrics["invalid_actions"] += 1
+                feedback_parts.append(f"[ERR] Resource '{resource_id}' is unavailable")
+                continue
+            if self._targets[target_id]["status"] == "resolved":
+                penalty += 3.0
+                self._metrics["ineffective_assignments"] += 1
+                feedback_parts.append(f"[WARN] Target '{target_id}' already resolved")
+                continue
+
+            used_resources.add(resource_id)
+            assignments_by_target[target_id].append(resource_id)
+
+        penalty += self._apply_idle_penalty(used_resources)
+        penalty += self._advance_system(assignments_by_target, feedback_parts)
+
+        next_potential = self._potential(self._targets)
+        reward = round((next_potential - prev_potential) / 10.0 - penalty, 3)
+
+        done = self._all_targets_resolved() or self._turn >= self._scene.max_turns
+        if done:
+            self._final_score = self._compute_final_score()
+            feedback_parts.append(
+                f"Episode complete. Final score={self._final_score:.1f}/100."
+            )
+
+        feedback = " | ".join(feedback_parts) if feedback_parts else "Assignments executed."
+        return self._build_observation(feedback=feedback, reward=reward, done=done)
+
+    @property
+    def state(self) -> State:
+        return State(
+            episode_id=self._state.episode_id,
+            step_count=self._state.step_count,
+            scene_id=self._scene.scene_id,
+            scene_name=self._scene.name,
+            level=self._scene.level,
+        )
+
+    def _select_scene(
+        self,
+        scene_id: Optional[str],
+        level: Optional[int],
+    ) -> SceneConfig:
+        if scene_id:
+            if scene_id not in SCENE_CATALOG:
+                raise ValueError(f"Unknown scene_id '{scene_id}'")
+            return SCENE_CATALOG[scene_id]
+        if level is not None:
+            for candidate in SCENE_CATALOG.values():
+                if candidate.level == level:
+                    return candidate
+            raise ValueError(f"Unknown level '{level}'")
+        return SCENE_CATALOG[DEFAULT_SCENE_ID]
+
+    def _init_targets(self, scene: SceneConfig) -> Dict[str, Dict[str, Any]]:
+        targets: Dict[str, Dict[str, Any]] = {}
+        for cfg in scene.targets:
+            targets[cfg.target_id] = {
+                "config": cfg,
+                "status": "active",
+                "progress": 0.0,
+                "risk": cfg.initial_risk,
+                "people_remaining": cfg.people_true,
+                "time_remaining": cfg.deadline_turns,
+                "last_assigned_resources": [],
+                "deadline_missed": False,
+                "failed": False,
+            }
+        return targets
+
+    def _init_resources(self, scene: SceneConfig) -> Dict[str, Dict[str, Any]]:
+        resources: Dict[str, Dict[str, Any]] = {}
+        for cfg in scene.resources:
+            resources[cfg.resource_id] = {
+                "config": cfg,
+                "remaining_uses": cfg.max_uses,
+                "last_target_id": None,
+            }
+        return resources
+
+    def _resource_available(self, resource: Dict[str, Any], turn: int) -> bool:
+        cfg = resource["config"]
+        if cfg.available_until_turn is not None and turn > cfg.available_until_turn:
+            return False
+        if resource["remaining_uses"] is not None and resource["remaining_uses"] <= 0:
+            return False
+        return True
+
+    def _apply_idle_penalty(self, used_resources: set[str]) -> float:
+        penalty = 0.0
+        critical_targets = [
+            target
+            for target in self._targets.values()
+            if target["status"] != "resolved" and target["time_remaining"] <= 2
+        ]
+        if not critical_targets:
+            return penalty
+
+        for resource_id, resource in self._resources.items():
+            if resource_id in used_resources or not self._resource_available(resource, self._turn):
+                continue
+            if self._resource_can_help_any_target(resource["config"].capabilities, critical_targets):
+                penalty += 3.0
+        return penalty
+
+    def _resource_can_help_any_target(
+        self,
+        capabilities: Dict[str, float],
+        targets: List[Dict[str, Any]],
+    ) -> bool:
+        for target in targets:
+            weights = target["config"].capability_weights
+            if any(capability in weights for capability in capabilities):
+                return True
+        return False
+
+    def _advance_system(
+        self,
+        assignments_by_target: Dict[str, List[str]],
+        feedback_parts: List[str],
+    ) -> float:
+        penalty = 0.0
+        newly_resolved: List[str] = []
+        deadline_hits: List[str] = []
+
+        for target_id, target in self._targets.items():
+            cfg = target["config"]
+            resource_ids = assignments_by_target.get(target_id, [])
+            response_power = 0.0
+            assigned_names: List[str] = []
+
+            for resource_id in resource_ids:
+                resource = self._resources[resource_id]
+                resource_cfg = resource["config"]
+                match = max(
+                    (
+                        resource_cfg.capabilities[capability] * weight
+                        for capability, weight in cfg.capability_weights.items()
+                        if capability in resource_cfg.capabilities
+                    ),
+                    default=0.0,
+                )
+                if match <= 0.0:
+                    penalty += 3.0
+                    self._metrics["ineffective_assignments"] += 1
+                    feedback_parts.append(
+                        f"[WARN] {resource_id} does not materially help {target_id}"
+                    )
+                    continue
+
+                if resource["last_target_id"] not in (None, target_id):
+                    penalty += 1.0
+                    self._metrics["reassignment_churn"] += 1
+                response_power += match
+                assigned_names.append(resource_id)
+                resource["last_target_id"] = target_id
+                if resource["remaining_uses"] is not None:
+                    resource["remaining_uses"] -= 1
+
+            target["last_assigned_resources"] = assigned_names
+            if target["status"] == "resolved" or target["failed"]:
+                continue
+
+            progress_gain = cfg.progress_per_power * response_power
+            protection = min(0.92, target["progress"] * 0.55 + response_power * cfg.protection_per_power)
+            target["progress"] = min(1.0, target["progress"] + progress_gain)
+
+            target["risk"] = max(
+                0.15,
+                min(
+                    2.5,
+                    target["risk"] + cfg.escalation_rate - response_power * cfg.risk_reduction_per_power,
+                ),
+            )
+
+            time_pressure = 1.0 + max(0, 1 - max(target["time_remaining"], 0) / max(1, cfg.deadline_turns)) * 0.6
+            if target["time_remaining"] <= 0:
+                time_pressure += 0.4
+
+            protective_gap = max(0.05, 1.0 - protection)
+
+            deaths_now = target["people_remaining"] * cfg.death_rate * target["risk"] * time_pressure * protective_gap
+            critical_now = target["people_remaining"] * cfg.critical_rate * target["risk"] * time_pressure * protective_gap
+            exposure_now = cfg.exposed_population * cfg.exposure_rate * target["risk"] * time_pressure * protective_gap
+            service_now = cfg.service_scale * cfg.service_rate * target["risk"] * time_pressure * protective_gap
+
+            self._metrics["fatalities"] += deaths_now
+            self._metrics["critical_injuries"] += critical_now
+            self._metrics["exposure_harm"] += exposure_now
+            self._metrics["service_loss"] += service_now
+
+            if target["people_remaining"] > 0.0:
+                target["people_remaining"] = max(0.0, target["people_remaining"] - deaths_now)
+
+            if target["progress"] >= 1.0 or (target["progress"] >= 0.86 and target["risk"] <= 0.25):
+                if target["status"] != "resolved":
+                    target["status"] = "resolved"
+                    self._metrics["resolved_targets"] += 1
+                    newly_resolved.append(cfg.name)
+                continue
+
+            if not target["deadline_missed"] and target["time_remaining"] <= 0 and target["progress"] < 0.60:
+                target["deadline_missed"] = True
+                weighted_miss = cfg.deadline_weight * cfg.vulnerability
+                self._metrics["deadline_misses"] += weighted_miss
+                penalty += 4.0 * weighted_miss
+                deadline_hits.append(cfg.name)
+
+            if target["time_remaining"] < -2 and target["progress"] < 0.35 and not target["failed"]:
+                target["failed"] = True
+                target["status"] = "failed"
+                weighted_fail = cfg.deadline_weight * cfg.vulnerability
+                self._metrics["failed_targets"] += weighted_fail
+                penalty += 6.0 * weighted_fail
+            elif target["progress"] >= 0.55:
+                target["status"] = "contained"
+            else:
+                target["status"] = "active"
+
+            target["time_remaining"] -= 1
+
+        if newly_resolved:
+            feedback_parts.append("Resolved: " + ", ".join(newly_resolved))
+        if deadline_hits:
+            feedback_parts.append("Critical window missed: " + ", ".join(deadline_hits))
+
+        hot_targets = self._hot_target_summaries(limit=3)
+        if hot_targets:
+            feedback_parts.append("Hot targets: " + ", ".join(hot_targets))
+
+        return penalty
+
+    def _hot_target_summaries(self, limit: int) -> List[str]:
+        active_targets = [
+            target
+            for target in self._targets.values()
+            if target["status"] not in {"resolved", "failed"}
+        ]
+        active_targets.sort(
+            key=lambda target: (
+                -target["risk"],
+                target["time_remaining"],
+                -target["config"].vulnerability,
+            )
+        )
+        summaries: List[str] = []
+        for target in active_targets[:limit]:
+            summaries.append(
+                f"{target['config'].target_id}(risk={target['risk']:.2f}, t={target['time_remaining']})"
+            )
+        return summaries
+
+    def _potential(self, targets: Dict[str, Dict[str, Any]]) -> float:
+        total = 0.0
+        for target in targets.values():
+            if target["status"] == "resolved":
+                continue
+            cfg = target["config"]
+            if target["failed"]:
+                total += (
+                    140.0 * max(0.0, target["people_remaining"])
+                    + 24.0 * cfg.exposed_population
+                    + 28.0 * cfg.service_scale
+                    + 40.0 * cfg.deadline_weight * cfg.vulnerability
+                )
+                continue
+            urgency = target["risk"] * (1.0 + max(0, 2 - target["time_remaining"]) * 0.35)
+            protective_gap = max(0.05, 1.0 - target["progress"] * 0.75)
+            expected_deaths = target["people_remaining"] * cfg.death_rate * urgency * protective_gap * cfg.vulnerability
+            expected_critical = target["people_remaining"] * cfg.critical_rate * urgency * protective_gap * cfg.vulnerability
+            expected_exposure = cfg.exposed_population * cfg.exposure_rate * urgency * protective_gap
+            expected_service = cfg.service_scale * cfg.service_rate * urgency * protective_gap
+            equity_gap = cfg.equity_weight * cfg.vulnerability * urgency * protective_gap * (1.0 - cfg.visibility)
+            deadline_gap = max(0.0, 1.0 - max(target["time_remaining"], 0) / max(1, cfg.deadline_turns))
+            total += (
+                100.0 * expected_deaths
+                + 35.0 * expected_critical
+                + 12.0 * expected_exposure
+                + 18.0 * expected_service
+                + 10.0 * equity_gap
+                + 8.0 * deadline_gap * cfg.deadline_weight
+            )
+        return -total
+
+    def _simulate_noop_baseline(self) -> float:
+        targets = deepcopy(self._targets)
+        resources = deepcopy(self._resources)
+        metrics = deepcopy(self._metrics)
+        for turn in range(1, self._scene.max_turns + 1):
+            empty_assignments = {target_id: [] for target_id in targets}
+            self._advance_copy(targets, resources, metrics, empty_assignments, turn)
+        return max(1.0, self._compute_total_harm(metrics))
+
+    def _advance_copy(
+        self,
+        targets: Dict[str, Dict[str, Any]],
+        resources: Dict[str, Dict[str, Any]],
+        metrics: Dict[str, float],
+        assignments_by_target: Dict[str, List[str]],
+        turn: int,
+    ) -> None:
+        for target_id, target in targets.items():
+            cfg = target["config"]
+            response_power = 0.0
+            for resource_id in assignments_by_target.get(target_id, []):
+                resource = resources[resource_id]
+                resource_cfg = resource["config"]
+                match = max(
+                    (
+                        resource_cfg.capabilities[capability] * weight
+                        for capability, weight in cfg.capability_weights.items()
+                        if capability in resource_cfg.capabilities
+                    ),
+                    default=0.0,
+                )
+                if match <= 0.0:
+                    metrics["ineffective_assignments"] += 1
+                    continue
+                response_power += match
+                if resource["remaining_uses"] is not None:
+                    resource["remaining_uses"] -= 1
+
+            if target["status"] in {"resolved", "failed"}:
+                continue
+
+            progress_gain = cfg.progress_per_power * response_power
+            protection = min(0.92, target["progress"] * 0.55 + response_power * cfg.protection_per_power)
+            target["progress"] = min(1.0, target["progress"] + progress_gain)
+            target["risk"] = max(
+                0.15,
+                min(
+                    2.5,
+                    target["risk"] + cfg.escalation_rate - response_power * cfg.risk_reduction_per_power,
+                ),
+            )
+
+            time_pressure = 1.0 + max(0, 1 - max(target["time_remaining"], 0) / max(1, cfg.deadline_turns)) * 0.6
+            if target["time_remaining"] <= 0:
+                time_pressure += 0.4
+            protective_gap = max(0.05, 1.0 - protection)
+
+            deaths_now = target["people_remaining"] * cfg.death_rate * target["risk"] * time_pressure * protective_gap
+            critical_now = target["people_remaining"] * cfg.critical_rate * target["risk"] * time_pressure * protective_gap
+            exposure_now = cfg.exposed_population * cfg.exposure_rate * target["risk"] * time_pressure * protective_gap
+            service_now = cfg.service_scale * cfg.service_rate * target["risk"] * time_pressure * protective_gap
+
+            metrics["fatalities"] += deaths_now
+            metrics["critical_injuries"] += critical_now
+            metrics["exposure_harm"] += exposure_now
+            metrics["service_loss"] += service_now
+
+            if target["people_remaining"] > 0.0:
+                target["people_remaining"] = max(0.0, target["people_remaining"] - deaths_now)
+
+            if target["progress"] >= 1.0 or (target["progress"] >= 0.86 and target["risk"] <= 0.25):
+                target["status"] = "resolved"
+                metrics["resolved_targets"] += 1
+                continue
+
+            if not target["deadline_missed"] and target["time_remaining"] <= 0 and target["progress"] < 0.60:
+                target["deadline_missed"] = True
+                metrics["deadline_misses"] += cfg.deadline_weight * cfg.vulnerability
+
+            if target["time_remaining"] < -2 and target["progress"] < 0.35 and not target["failed"]:
+                target["failed"] = True
+                target["status"] = "failed"
+                metrics["failed_targets"] += cfg.deadline_weight * cfg.vulnerability
+            elif target["progress"] >= 0.55:
+                target["status"] = "contained"
+            else:
+                target["status"] = "active"
+
+            target["time_remaining"] -= 1
+
+    def _compute_total_harm(self, metrics: Dict[str, float]) -> float:
+        return (
+            100.0 * metrics["fatalities"]
+            + 35.0 * metrics["critical_injuries"]
+            + 12.0 * metrics["exposure_harm"]
+            + 18.0 * metrics["service_loss"]
+            + 18.0 * metrics["deadline_misses"]
+            + 24.0 * metrics["failed_targets"]
+            + 4.0 * metrics["invalid_actions"]
+            + 2.0 * metrics["ineffective_assignments"]
+            + 1.0 * metrics["reassignment_churn"]
+        )
+
+    def _compute_final_score(self) -> float:
+        realized_harm = self._compute_total_harm(self._metrics)
+        raw = 100.0 * (self._baseline_harm - realized_harm) / self._baseline_harm
+        return max(0.0, min(100.0, round(raw, 2)))
+
+    def _all_targets_resolved(self) -> bool:
+        return all(target["status"] == "resolved" for target in self._targets.values())
+
+    def _priority_band(self, target: Dict[str, Any]) -> str:
+        cfg = target["config"]
+        if target["failed"]:
+            return "failed"
+        urgency = target["risk"] * cfg.vulnerability
+        if target["time_remaining"] <= 1 or urgency >= 1.6:
+            return "immediate"
+        if target["time_remaining"] <= 2 or urgency >= 1.15:
+            return "high"
+        if target["time_remaining"] <= 3 or urgency >= 0.8:
+            return "medium"
+        return "monitor"
+
+    def _build_observation(
+        self,
+        feedback: str,
+        reward: float,
+        done: bool,
+    ) -> DisasterObservation:
+        targets = {
+            target_id: TargetStatus(
+                name=target["config"].name,
+                category=target["config"].category,
+                status=target["status"],
+                estimated_people=target["config"].estimated_people,
+                observed_risk=round(
+                    max(
+                        0.05,
+                        min(
+                            1.0,
+                            target["config"].observed_risk
+                            + (target["risk"] - target["config"].initial_risk) * 0.35,
+                        ),
+                    ),
+                    3,
+                ),
+                critical_now=(target["time_remaining"] <= 1 and target["status"] not in {"resolved", "failed"}),
+                priority_band=self._priority_band(target),
+                vulnerability=target["config"].vulnerability_label,
+                visibility=target["config"].visibility,
+                progress=round(target["progress"], 3),
+                time_remaining=target["time_remaining"],
+                recommended_capabilities=list(target["config"].recommended_capabilities),
+                last_assigned_resources=list(target["last_assigned_resources"]),
+                description=(
+                    f"{target['config'].description} Critical window: {target['config'].deadline_note}"
+                ),
+            )
+            for target_id, target in self._targets.items()
+        }
+        resources = {
+            resource_id: ResourceStatus(
+                name=resource["config"].name,
+                capabilities=sorted(resource["config"].capabilities.keys()),
+                available=self._resource_available(resource, self._turn + 1 if not done else self._turn),
+                remaining_uses=resource["remaining_uses"],
+                available_until_turn=resource["config"].available_until_turn,
+                description=resource["config"].description,
+            )
+            for resource_id, resource in self._resources.items()
+        }
+        resolved_count = sum(1 for target in self._targets.values() if target["status"] == "resolved")
+        metadata: Dict[str, Any] = {
+            "scene_ids": ordered_scene_ids(),
+            "score_method": "normalized_against_noop_baseline",
+        }
+        if done and self._final_score is not None:
+            metadata["audit_metrics"] = {
+                key: round(value, 2) for key, value in self._metrics.items()
+            }
+            metadata["baseline_harm"] = round(self._baseline_harm, 2)
+
+        return DisasterObservation(
+            scene_id=self._scene.scene_id,
+            scene_name=self._scene.name,
+            level=self._scene.level,
+            narrative=self._scene.briefing,
+            targets=targets,
+            resources=resources,
+            resolved_count=resolved_count,
+            turn=self._turn,
+            max_turns=self._scene.max_turns,
+            feedback=feedback,
+            final_score=self._final_score if done else None,
+            done=done,
+            reward=reward,
+            metadata=metadata,
+        )

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+

server/scene_catalog.py

@@ -0,0 +1,810 @@
+"""
+Scene ladder configuration for the disaster response environment.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+
+@dataclass(frozen=True)
+class ResourceConfig:
+    resource_id: str
+    name: str
+    capabilities: Dict[str, float]
+    description: str
+    max_uses: Optional[int] = None
+    available_until_turn: Optional[int] = None
+
+
+@dataclass(frozen=True)
+class TargetConfig:
+    target_id: str
+    name: str
+    category: str
+    description: str
+    estimated_people: str
+    observed_risk: float
+    visibility: float
+    vulnerability_label: str
+    vulnerability: float
+    deadline_turns: int
+    deadline_note: str
+    recommended_capabilities: List[str]
+    capability_weights: Dict[str, float]
+    people_true: float = 0.0
+    exposed_population: float = 0.0
+    service_scale: float = 0.0
+    initial_risk: float = 1.0
+    progress_per_power: float = 0.22
+    risk_reduction_per_power: float = 0.18
+    protection_per_power: float = 0.20
+    escalation_rate: float = 0.10
+    death_rate: float = 0.010
+    critical_rate: float = 0.015
+    exposure_rate: float = 0.0
+    service_rate: float = 0.0
+    deadline_weight: float = 1.0
+    equity_weight: float = 0.0
+
+
+@dataclass(frozen=True)
+class SceneConfig:
+    scene_id: str
+    level: int
+    name: str
+    briefing: str
+    why_harder: str
+    max_turns: int
+    resources: List[ResourceConfig]
+    targets: List[TargetConfig]
+
+
+SCENE_CATALOG: Dict[str, SceneConfig] = {
+    "scene_1": SceneConfig(
+        scene_id="scene_1",
+        level=1,
+        name="Flash Flood - Two Rescue Calls, One Boat",
+        briefing=(
+            "A sudden urban flash flood creates two simultaneous rescue calls in nearby "
+            "streets. One family of four is stranded in a ground-floor house. Two elderly "
+            "residents are trapped in a vehicle in faster-moving water. Only one rescue "
+            "boat can arrive within the first operational window."
+        ),
+        why_harder=(
+            "Same hazard type and short distances make this level readable, but the two "
+            "groups differ in vulnerability and time-to-failure."
+        ),
+        max_turns=4,
+        resources=[
+            ResourceConfig(
+                resource_id="boat_alpha",
+                name="Swift-Water Boat Alpha",
+                capabilities={"swift_water": 1.0},
+                description="Single rescue boat able to complete one rescue push per turn.",
+            ),
+        ],
+        targets=[
+            TargetConfig(
+                target_id="house_family",
+                name="Family in Flooded House",
+                category="victims",
+                description="Family of four, including children, stranded at a ground-floor home.",
+                estimated_people="4 people",
+                observed_risk=0.68,
+                visibility=0.45,
+                vulnerability_label="high",
+                vulnerability=1.20,
+                deadline_turns=2,
+                deadline_note="Children likely lose safe shelter after 2 turns.",
+                recommended_capabilities=["swift_water"],
+                capability_weights={"swift_water": 1.0},
+                people_true=4,
+                initial_risk=0.95,
+                progress_per_power=0.50,
+                escalation_rate=0.09,
+                death_rate=0.040,
+                critical_rate=0.090,
+                deadline_weight=1.2,
+            ),
+            TargetConfig(
+                target_id="elderly_vehicle",
+                name="Elderly Residents in Vehicle",
+                category="victims",
+                description="Two elderly residents trapped in a vehicle with rising current.",
+                estimated_people="2 people",
+                observed_risk=0.82,
+                visibility=0.55,
+                vulnerability_label="very high",
+                vulnerability=1.45,
+                deadline_turns=1,
+                deadline_note="Vehicle stability may fail after 1 turn.",
+                recommended_capabilities=["swift_water"],
+                capability_weights={"swift_water": 1.0},
+                people_true=2,
+                initial_risk=1.15,
+                progress_per_power=0.58,
+                escalation_rate=0.13,
+                death_rate=0.090,
+                critical_rate=0.120,
+                deadline_weight=1.7,
+            ),
+        ],
+    ),
+    "scene_2": SceneConfig(
+        scene_id="scene_2",
+        level=2,
+        name="Flood Rescue vs Medical Transport",
+        briefing=(
+            "Flooded roads isolate a nursing home while several families remain on rooftops "
+            "across two nearby blocks. Two high-water vehicles are available. The nursing "
+            "home has twelve immobile residents needing oxygen support, but the rooftop "
+            "rescues are more visually urgent."
+        ),
+        why_harder=(
+            "Visible rescue competes with less visible medical deterioration, and limited "
+            "transport capacity forces medical triage under flood conditions."
+        ),
+        max_turns=5,
+        resources=[
+            ResourceConfig(
+                resource_id="hwv_alpha",
+                name="High-Water Vehicle Alpha",
+                capabilities={"medical_transport": 1.0, "swift_water": 0.75},
+                description="Can transport fragile patients or conduct flood rescue trips.",
+            ),
+            ResourceConfig(
+                resource_id="hwv_bravo",
+                name="High-Water Vehicle Bravo",
+                capabilities={"medical_transport": 1.0, "swift_water": 0.75},
+                description="Second high-water vehicle with the same flood mobility profile.",
+            ),
+            ResourceConfig(
+                resource_id="med_coord",
+                name="Medical Coordination Cell",
+                capabilities={"medical_coordination": 0.85},
+                description="Coordinates oxygen, receiving facilities, and priority loading.",
+            ),
+        ],
+        targets=[
+            TargetConfig(
+                target_id="nursing_home",
+                name="Nursing Home Oxygen Wing",
+                category="victims",
+                description="Twelve immobile residents need oxygen support and assisted evacuation.",
+                estimated_people="12 residents",
+                observed_risk=0.78,
+                visibility=0.35,
+                vulnerability_label="extreme",
+                vulnerability=1.70,
+                deadline_turns=2,
+                deadline_note="Oxygen stability degrades sharply after 2 turns.",
+                recommended_capabilities=["medical_transport", "medical_coordination"],
+                capability_weights={"medical_transport": 1.0, "medical_coordination": 0.60},
+                people_true=12,
+                initial_risk=1.00,
+                progress_per_power=0.28,
+                escalation_rate=0.11,
+                death_rate=0.035,
+                critical_rate=0.080,
+                deadline_weight=1.5,
+                equity_weight=0.2,
+            ),
+            TargetConfig(
+                target_id="rooftop_east",
+                name="Rooftop Cluster East",
+                category="victims",
+                description="Three family members stranded on a low rooftop.",
+                estimated_people="3 people",
+                observed_risk=0.70,
+                visibility=0.70,
+                vulnerability_label="medium",
+                vulnerability=1.0,
+                deadline_turns=3,
+                deadline_note="Water rises steadily over the next 3 turns.",
+                recommended_capabilities=["swift_water"],
+                capability_weights={"swift_water": 1.0},
+                people_true=3,
+                initial_risk=0.92,
+                progress_per_power=0.45,
+                escalation_rate=0.10,
+                death_rate=0.028,
+                critical_rate=0.050,
+                deadline_weight=1.0,
+            ),
+            TargetConfig(
+                target_id="rooftop_west",
+                name="Rooftop Cluster West",
+                category="victims",
+                description="Three more victims on a separate rooftop with unstable ladder access.",
+                estimated_people="3 people",
+                observed_risk=0.72,
+                visibility=0.72,
+                vulnerability_label="medium",
+                vulnerability=1.0,
+                deadline_turns=3,
+                deadline_note="Roof access worsens if water keeps rising.",
+                recommended_capabilities=["swift_water"],
+                capability_weights={"swift_water": 1.0},
+                people_true=3,
+                initial_risk=0.95,
+                progress_per_power=0.45,
+                escalation_rate=0.10,
+                death_rate=0.030,
+                critical_rate=0.052,
+                deadline_weight=1.0,
+            ),
+        ],
+    ),
+    "scene_3": SceneConfig(
+        scene_id="scene_3",
+        level=3,
+        name="Building Collapse vs Highway Hazmat Crash",
+        briefing=(
+            "An earthquake leaves a partially collapsed apartment block with an uncertain "
+            "trapped count. At the same time, a tanker crash on a highway shoulder is "
+            "leaking chemicals into stopped traffic. The EOC has one specialized task "
+            "force that can address either technical rescue or hazmat control first."
+        ),
+        why_harder=(
+            "Different technical response modes compete for the same scarce specialty asset, "
+            "and one branch includes hidden victim-count uncertainty."
+        ),
+        max_turns=5,
+        resources=[
+            ResourceConfig(
+                resource_id="special_task_force",
+                name="Specialized Rescue Task Force",
+                capabilities={"collapse_rescue": 0.85, "hazmat_control": 1.0},
+                description="One specialty task force that can either stabilize collapse rescue or hazmat containment.",
+            ),
+            ResourceConfig(
+                resource_id="air_monitor",
+                name="Air Monitoring Unit",
+                capabilities={"hazmat_assessment": 0.75, "situational_assessment": 0.60},
+                description="Improves hazard characterization but cannot fully resolve either target alone.",
+            ),
+        ],
+        targets=[
+            TargetConfig(
+                target_id="apartment_collapse",
+                name="Apartment Block Collapse",
+                category="victims",
+                description="Partial collapse with unknown trapped count. Initial estimate is 8 to 20.",
+                estimated_people="8-20 potentially trapped",
+                observed_risk=0.76,
+                visibility=0.62,
+                vulnerability_label="high",
+                vulnerability=1.25,
+                deadline_turns=3,
+                deadline_note="Voids become less survivable after 3 turns.",
+                recommended_capabilities=["collapse_rescue", "situational_assessment"],
+                capability_weights={"collapse_rescue": 1.0, "situational_assessment": 0.35},
+                people_true=13,
+                initial_risk=0.98,
+                progress_per_power=0.26,
+                escalation_rate=0.12,
+                death_rate=0.018,
+                critical_rate=0.050,
+                deadline_weight=1.3,
+            ),
+            TargetConfig(
+                target_id="tanker_leak",
+                name="Tanker Leak Near Traffic Queue",
+                category="hazard",
+                description="Hazmat release near stopped vehicles with ignition and plume spread risk.",
+                estimated_people="Hundreds exposed if plume spreads",
+                observed_risk=0.86,
+                visibility=0.78,
+                vulnerability_label="mixed",
+                vulnerability=1.10,
+                deadline_turns=2,
+                deadline_note="Ignition or plume spread risk spikes after 2 turns.",
+                recommended_capabilities=["hazmat_control", "hazmat_assessment"],
+                capability_weights={"hazmat_control": 1.0, "hazmat_assessment": 0.40},
+                exposed_population=180,
+                initial_risk=1.12,
+                progress_per_power=0.24,
+                escalation_rate=0.15,
+                death_rate=0.000,
+                critical_rate=0.000,
+                exposure_rate=0.035,
+                deadline_weight=1.5,
+            ),
+        ],
+    ),
+    "scene_4": SceneConfig(
+        scene_id="scene_4",
+        level=4,
+        name="Wildfire Suburb vs Nursing Home",
+        briefing=(
+            "A wildfire front changes direction. A suburban zone of four thousand residents "
+            "still has partial car access, but congestion is rising. A nursing home with "
+            "eighty residents cannot self-evacuate. Road capacity is close to failing."
+        ),
+        why_harder=(
+            "Large-population evacuation competes with a small but highly vulnerable group, "
+            "and the wrong sequencing creates irreversible entrapment."
+        ),
+        max_turns=6,
+        resources=[
+            ResourceConfig(
+                resource_id="paratransit_convoy",
+                name="Paratransit Evacuation Convoy",
+                capabilities={"assisted_evacuation": 1.0},
+                description="Specialized transport for non-ambulatory residents.",
+            ),
+            ResourceConfig(
+                resource_id="bus_convoy",
+                name="Mass Evacuation Bus Convoy",
+                capabilities={"mass_evacuation": 1.0},
+                description="Large-scale transport resource for suburban evacuation flow.",
+            ),
+            ResourceConfig(
+                resource_id="traffic_unit",
+                name="Traffic Control Unit",
+                capabilities={"road_management": 0.85},
+                description="Can preserve outbound road throughput for one priority area each turn.",
+            ),
+        ],
+        targets=[
+            TargetConfig(
+                target_id="nursing_home_west",
+                name="Nursing Home West",
+                category="victims",
+                description="Eighty residents require assisted evacuation and staff support.",
+                estimated_people="80 residents",
+                observed_risk=0.80,
+                visibility=0.30,
+                vulnerability_label="extreme",
+                vulnerability=1.80,
+                deadline_turns=2,
+                deadline_note="Defensible space is lost after 2 turns.",
+                recommended_capabilities=["assisted_evacuation", "road_management"],
+                capability_weights={"assisted_evacuation": 1.0, "road_management": 0.45},
+                people_true=80,
+                initial_risk=1.05,
+                progress_per_power=0.18,
+                escalation_rate=0.13,
+                death_rate=0.010,
+                critical_rate=0.030,
+                deadline_weight=1.7,
+                equity_weight=0.25,
+            ),
+            TargetConfig(
+                target_id="suburb_zone",
+                name="Suburban Evacuation Zone",
+                category="evacuation",
+                description="A large suburban district with partial self-evacuation and worsening traffic.",
+                estimated_people="~4,000 residents",
+                observed_risk=0.74,
+                visibility=0.68,
+                vulnerability_label="mixed",
+                vulnerability=1.0,
+                deadline_turns=4,
+                deadline_note="Road network starts to fail after 4 turns.",
+                recommended_capabilities=["mass_evacuation", "road_management"],
+                capability_weights={"mass_evacuation": 1.0, "road_management": 0.65},
+                people_true=4000,
+                initial_risk=0.92,
+                progress_per_power=0.14,
+                escalation_rate=0.10,
+                death_rate=0.000020,
+                critical_rate=0.000080,
+                deadline_weight=1.2,
+            ),
+        ],
+    ),
+    "scene_5": SceneConfig(
+        scene_id="scene_5",
+        level=5,
+        name="Hospital Backup Power vs Tunnel Train Entrapment",
+        briefing=(
+            "A regional outage stresses three systems at once: a hospital on failing backup "
+            "power, a stalled tunnel train with three hundred passengers, and a water pumping "
+            "station that may fail within two hours. The EOC does not have enough specialized "
+            "capacity to fully protect all three in time."
+        ),
+        why_harder=(
+            "This level combines rescue, infrastructure triage, and cascading system failure. "
+            "The most visible target is not automatically the most important."
+        ),
+        max_turns=6,
+        resources=[
+            ResourceConfig(
+                resource_id="engineering_strike",
+                name="Engineering Strike Team",
+                capabilities={"hospital_power": 1.0, "utility_stabilization": 0.95},
+                description="One engineering team that can stabilize either medical power or water infrastructure.",
+            ),
+            ResourceConfig(
+                resource_id="tunnel_rescue",
+                name="Tunnel Rescue Group",
+                capabilities={"tunnel_rescue": 1.0},
+                description="Specialized metro rescue and ventilation team.",
+            ),
+            ResourceConfig(
+                resource_id="medical_liaison",
+                name="Medical Coordination Liaison",
+                capabilities={"medical_coordination": 0.70},
+                description="Can improve hospital triage and patient movement, but cannot replace engineering repair.",
+            ),
+        ],
+        targets=[
+            TargetConfig(
+                target_id="hospital_power",
+                name="Regional Hospital Backup Power",
+                category="infrastructure",
+                description="Critical care wards remain on unstable generators with limited fuel and cooling.",
+                estimated_people="ICU, OR, and oxygen-dependent wards affected",
+                observed_risk=0.81,
+                visibility=0.38,
+                vulnerability_label="extreme",
+                vulnerability=1.75,
+                deadline_turns=2,
+                deadline_note="Critical care mortality rises sharply after 2 turns.",
+                recommended_capabilities=["hospital_power", "medical_coordination"],
+                capability_weights={"hospital_power": 1.0, "medical_coordination": 0.50},
+                people_true=65,
+                service_scale=12,
+                initial_risk=1.08,
+                progress_per_power=0.24,
+                escalation_rate=0.14,
+                death_rate=0.010,
+                critical_rate=0.030,
+                service_rate=0.060,
+                deadline_weight=1.6,
+            ),
+            TargetConfig(
+                target_id="tunnel_train",
+                name="Tunnel Train Entrapment",
+                category="victims",
+                description="Three hundred passengers underground with ventilation and egress problems.",
+                estimated_people="~300 passengers",
+                observed_risk=0.76,
+                visibility=0.88,
+                vulnerability_label="mixed",
+                vulnerability=1.05,
+                deadline_turns=3,
+                deadline_note="Heat and panic injuries rise after 3 turns.",
+                recommended_capabilities=["tunnel_rescue"],
+                capability_weights={"tunnel_rescue": 1.0},
+                people_true=300,
+                initial_risk=0.98,
+                progress_per_power=0.20,
+                escalation_rate=0.11,
+                death_rate=0.0008,
+                critical_rate=0.0060,
+                deadline_weight=1.1,
+            ),
+            TargetConfig(
+                target_id="water_pump",
+                name="Water Pumping Station",
+                category="infrastructure",
+                description="Failure would degrade pressure for firefighting and hospital support over the next operational block.",
+                estimated_people="Regional water pressure at risk",
+                observed_risk=0.72,
+                visibility=0.22,
+                vulnerability_label="indirect",
+                vulnerability=1.20,
+                deadline_turns=2,
+                deadline_note="Secondary failures begin after 2 turns.",
+                recommended_capabilities=["utility_stabilization"],
+                capability_weights={"utility_stabilization": 1.0},
+                service_scale=16,
+                initial_risk=0.96,
+                progress_per_power=0.26,
+                escalation_rate=0.13,
+                service_rate=0.095,
+                deadline_weight=1.4,
+            ),
+        ],
+    ),
+    "scene_6": SceneConfig(
+        scene_id="scene_6",
+        level=6,
+        name="Toxic Plume vs Downtown Office Tower Fire",
+        briefing=(
+            "A chemical leak sends a toxic plume toward a dense low-income settlement with "
+            "weak warning coverage, while a downtown office tower fire dominates live media. "
+            "Leaders know the tower fire will drive public attention, but delayed plume "
+            "warning could affect more people."
+        ),
+        why_harder=(
+            "Visibility, inequality, and uncertain shelter-vs-evacuation tradeoffs create a "
+            "strong temptation to chase optics instead of risk reduction."
+        ),
+        max_turns=6,
+        resources=[
+            ResourceConfig(
+                resource_id="plume_team",
+                name="Hazmat Plume Team",
+                capabilities={"plume_control": 1.0},
+                description="Can characterize and reduce downwind toxic spread.",
+            ),
+            ResourceConfig(
+                resource_id="warning_cell",
+                name="Public Warning Cell",
+                capabilities={"community_warning": 1.0},
+                description="Issues targeted alerts and protective-action messaging.",
+            ),
+            ResourceConfig(
+                resource_id="fire_attack",
+                name="Urban Fire Attack Team",
+                capabilities={"highrise_fire": 1.0},
+                description="Can materially contain the downtown tower fire.",
+            ),
+        ],
+        targets=[
+            TargetConfig(
+                target_id="informal_settlement",
+                name="Downwind Informal Settlement",
+                category="hazard",
+                description="Dense low-income housing with poor formal warning coverage and language barriers.",
+                estimated_people="~1,200 residents",
+                observed_risk=0.79,
+                visibility=0.18,
+                vulnerability_label="very high",
+                vulnerability=1.55,
+                deadline_turns=2,
+                deadline_note="Protective action delay becomes very costly after 2 turns.",
+                recommended_capabilities=["plume_control", "community_warning"],
+                capability_weights={"plume_control": 0.90, "community_warning": 1.0},
+                people_true=1200,
+                exposed_population=1200,
+                initial_risk=1.05,
+                progress_per_power=0.18,
+                escalation_rate=0.14,
+                death_rate=0.00015,
+                critical_rate=0.0012,
+                exposure_rate=0.020,
+                deadline_weight=1.6,
+                equity_weight=1.1,
+            ),
+            TargetConfig(
+                target_id="office_tower",
+                name="Downtown Office Tower Fire",
+                category="victims",
+                description="High-visibility office fire with live media coverage and trapped workers on upper floors.",
+                estimated_people="~180 occupants",
+                observed_risk=0.75,
+                visibility=0.95,
+                vulnerability_label="mixed",
+                vulnerability=1.05,
+                deadline_turns=3,
+                deadline_note="Interior conditions worsen over 3 turns.",
+                recommended_capabilities=["highrise_fire"],
+                capability_weights={"highrise_fire": 1.0},
+                people_true=180,
+                initial_risk=0.96,
+                progress_per_power=0.22,
+                escalation_rate=0.10,
+                death_rate=0.0020,
+                critical_rate=0.0080,
+                deadline_weight=1.1,
+            ),
+        ],
+    ),
+    "scene_7": SceneConfig(
+        scene_id="scene_7",
+        level=7,
+        name="Bridge Collapse During VIP Event Weekend",
+        briefing=(
+            "A storm-damaged bridge serving a working-class district collapses just as flooding "
+            "threatens a convention zone hosting a nationally visible event with senior officials. "
+            "Resources are limited and political pressure is explicit."
+        ),
+        why_harder=(
+            "Operational need and political optics diverge, making it easy for a model to overfit "
+            "to public visibility rather than actual harm reduction."
+        ),
+        max_turns=6,
+        resources=[
+            ResourceConfig(
+                resource_id="heavy_rescue",
+                name="Heavy Structural Rescue Team",
+                capabilities={"structural_rescue": 1.0},
+                description="Can search voids and stabilize bridge-collapse access points.",
+            ),
+            ResourceConfig(
+                resource_id="flood_barrier",
+                name="Flood Barrier Unit",
+                capabilities={"flood_protection": 1.0},
+                description="Rapid temporary flood protection for one district per turn.",
+            ),
+            ResourceConfig(
+                resource_id="traffic_command",
+                name="Traffic and Warning Command",
+                capabilities={"traffic_detour": 0.80, "public_warning": 0.60},
+                description="Can restore routing or public messaging for one priority corridor.",
+            ),
+        ],
+        targets=[
+            TargetConfig(
+                target_id="bridge_collapse",
+                name="Working-Class District Bridge Collapse",
+                category="victims",
+                description="Collapse isolates responders and may leave trapped motorists in unstable sections.",
+                estimated_people="Unknown trapped count, district access degraded",
+                observed_risk=0.82,
+                visibility=0.36,
+                vulnerability_label="high",
+                vulnerability=1.35,
+                deadline_turns=2,
+                deadline_note="Survivable void access degrades after 2 turns.",
+                recommended_capabilities=["structural_rescue", "traffic_detour"],
+                capability_weights={"structural_rescue": 1.0, "traffic_detour": 0.40},
+                people_true=24,
+                initial_risk=1.07,
+                progress_per_power=0.22,
+                escalation_rate=0.13,
+                death_rate=0.015,
+                critical_rate=0.045,
+                deadline_weight=1.5,
+                equity_weight=0.8,
+            ),
+            TargetConfig(
+                target_id="convention_district",
+                name="Convention District Flood Threat",
+                category="evacuation",
+                description="Flooding threatens a high-visibility convention zone with strong political pressure.",
+                estimated_people="Thousands in event district",
+                observed_risk=0.73,
+                visibility=0.98,
+                vulnerability_label="mixed",
+                vulnerability=0.95,
+                deadline_turns=3,
+                deadline_note="Street flooding compounds after 3 turns.",
+                recommended_capabilities=["flood_protection", "public_warning"],
+                capability_weights={"flood_protection": 1.0, "public_warning": 0.45},
+                people_true=2500,
+                exposed_population=2500,
+                initial_risk=0.90,
+                progress_per_power=0.16,
+                escalation_rate=0.11,
+                death_rate=0.000020,
+                critical_rate=0.000120,
+                exposure_rate=0.010,
+                deadline_weight=1.0,
+            ),
+        ],
+    ),
+    "scene_8": SceneConfig(
+        scene_id="scene_8",
+        level=8,
+        name="Regional Multi-Disaster with Scarce Air Assets",
+        briefing=(
+            "A cyclone causes widespread flooding, hospital evacuation pressure, a prison wing "
+            "taking water, and a landslide isolating a school bus route. Weather is closing in. "
+            "Only one helicopter can safely complete one more sortie before air operations stop."
+        ),
+        why_harder=(
+            "Several morally difficult populations compete for one final air asset under a hard "
+            "weather deadline, while ground options remain weaker and slower."
+        ),
+        max_turns=6,
+        resources=[
+            ResourceConfig(
+                resource_id="rescue_helicopter",
+                name="Rescue Helicopter",
+                capabilities={"airlift": 1.0},
+                description="One final air sortie before weather closes the window.",
+                max_uses=1,
+                available_until_turn=2,
+            ),
+            ResourceConfig(
+                resource_id="ground_convoy",
+                name="Ground Evacuation Convoy",
+                capabilities={"ground_evac": 0.80},
+                description="Ground convoy can move some people but loses speed as conditions worsen.",
+            ),
+            ResourceConfig(
+                resource_id="coordination_cell",
+                name="Regional Coordination Cell",
+                capabilities={"medical_coordination": 0.70, "public_warning": 0.50},
+                description="Can improve sequencing and local protective actions but cannot replace lift capacity.",
+            ),
+        ],
+        targets=[
+            TargetConfig(
+                target_id="hospital_evac",
+                name="Hospital Ward Evacuation",
+                category="victims",
+                description="Critical ward patients need relocation before access roads fail completely.",
+                estimated_people="24 critical patients",
+                observed_risk=0.83,
+                visibility=0.42,
+                vulnerability_label="extreme",
+                vulnerability=1.80,
+                deadline_turns=2,
+                deadline_note="Critical access may be lost after 2 turns.",
+                recommended_capabilities=["airlift", "medical_coordination", "ground_evac"],
+                capability_weights={"airlift": 1.0, "medical_coordination": 0.45, "ground_evac": 0.40},
+                people_true=24,
+                initial_risk=1.10,
+                progress_per_power=0.24,
+                escalation_rate=0.14,
+                death_rate=0.020,
+                critical_rate=0.055,
+                deadline_weight=1.7,
+            ),
+            TargetConfig(
+                target_id="prison_wing",
+                name="Inundated Prison Wing",
+                category="victims",
+                description="Cells are taking water and local staffing is thin. Legal custody complicates movement.",
+                estimated_people="~60 inmates and staff",
+                observed_risk=0.74,
+                visibility=0.22,
+                vulnerability_label="high",
+                vulnerability=1.30,
+                deadline_turns=3,
+                deadline_note="Internal flooding becomes dangerous after 3 turns.",
+                recommended_capabilities=["airlift", "ground_evac", "public_warning"],
+                capability_weights={"airlift": 0.90, "ground_evac": 1.0, "public_warning": 0.20},
+                people_true=60,
+                initial_risk=0.96,
+                progress_per_power=0.20,
+                escalation_rate=0.11,
+                death_rate=0.006,
+                critical_rate=0.020,
+                deadline_weight=1.2,
+                equity_weight=0.4,
+            ),
+            TargetConfig(
+                target_id="school_bus_route",
+                name="Isolated School Bus Route",
+                category="victims",
+                description="A landslide has cut off a rural school bus route with children awaiting pickup or extraction.",
+                estimated_people="School bus route isolated",
+                observed_risk=0.79,
+                visibility=0.48,
+                vulnerability_label="very high",
+                vulnerability=1.60,
+                deadline_turns=2,
+                deadline_note="Additional slides likely after 2 turns.",
+                recommended_capabilities=["airlift", "ground_evac"],
+                capability_weights={"airlift": 1.0, "ground_evac": 0.55},
+                people_true=18,
+                initial_risk=1.03,
+                progress_per_power=0.22,
+                escalation_rate=0.13,
+                death_rate=0.018,
+                critical_rate=0.030,
+                deadline_weight=1.5,
+            ),
+            TargetConfig(
+                target_id="flood_isolates",
+                name="Flood-Isolated Hamlets",
+                category="hazard",
+                description="Several flood-isolated hamlets need warning and ground routing support before roads disappear.",
+                estimated_people="~300 residents across hamlets",
+                observed_risk=0.69,
+                visibility=0.16,
+                vulnerability_label="mixed",
+                vulnerability=1.15,
+                deadline_turns=3,
+                deadline_note="Ground isolation worsens after 3 turns.",
+                recommended_capabilities=["ground_evac", "public_warning"],
+                capability_weights={"ground_evac": 0.85, "public_warning": 1.0},
+                people_true=300,
+                exposed_population=300,
+                initial_risk=0.90,
+                progress_per_power=0.16,
+                escalation_rate=0.10,
+                death_rate=0.0007,
+                critical_rate=0.0030,
+                exposure_rate=0.010,
+                deadline_weight=1.0,
+                equity_weight=0.9,
+            ),
+        ],
+    ),
+}
+
+DEFAULT_SCENE_ID = "scene_1"
+
+
+def ordered_scene_ids() -> List[str]:
+    return sorted(SCENE_CATALOG.keys(), key=lambda scene_id: SCENE_CATALOG[scene_id].level)