Upload folder using huggingface_hub

app/environment/core.py

@@ -1,6 +1,6 @@
 import json
 from pathlib import Path
-from typing import Any, Callable, Literal, TypedDict, cast
+from typing import Any, Literal, cast
 
 from app.environment.graders import grade_task
 from app.environment.scenarios.accident import generate_accident_case
@@ -15,17 +15,7 @@ from app.utils.calculations import compute_speed_kmh, compute_travel_time_minute
 from app.utils.randomizer import SeededRandomizer
 
 
-TaskId = Literal["acde_easy", "acde_medium", "acde_hard"]
-Difficulty = Literal["easy", "medium", "hard"]
-ScenarioType = Literal["medical", "accident", "fire"]
-
-
-class TaskConfig(TypedDict):
-    difficulty: Difficulty
-    objective: str
-
-
-TASKS: dict[TaskId, TaskConfig] = {
+TASKS = {
     "acde_easy": {
         "difficulty": "easy",
         "objective": "Stabilize quickly while information is mostly reliable.",
@@ -40,17 +30,13 @@ TASKS: dict[TaskId, TaskConfig] = {
     },
 }
 
-MIN_REWARD = 0.01
-MAX_REWARD = 0.99
+MIN_REWARD = 0.001
+MAX_REWARD = 0.999
 
 OUTCOME_SCORE = {"accepted": 3, "partial": 2, "rejected": 1}
 CONDITION_ORDER = ["stable", "serious", "unstable", "critical"]
 
 
-def _clamp(value: float) -> float:
-    return max(MIN_REWARD, min(MAX_REWARD, float(value)))
-
-
 class EmergencyEnv:
     """Stateful local RL environment for emergency routing under uncertainty."""
 
@@ -73,9 +59,7 @@ class EmergencyEnv:
         if seed is None:
             seed = self._rng.randint(1, 10**9)
 
-        resolved_task_id: TaskId = (
-            cast(TaskId, task_id) if task_id in TASKS else cast(TaskId, self._rng.choice(list(TASKS.keys())))
-        )
+        resolved_task_id = cast(Literal["acde_easy", "acde_medium", "acde_hard"], task_id if task_id in TASKS else self._rng.choice(list(TASKS.keys())))
         difficulty = TASKS[resolved_task_id]["difficulty"]
 
         self._rng = SeededRandomizer(seed)
@@ -98,11 +82,11 @@ class EmergencyEnv:
         self.state_data = EnvState(
             episode_id=self.episode_counter,
             seed=seed,
-            task_id=resolved_task_id,
+            task_id=cast(Literal["acde_easy", "acde_medium", "acde_hard"], resolved_task_id),
             task_objective=TASKS[resolved_task_id]["objective"],
-            scenario_type=scenario_type,
+            scenario_type=cast(Literal["medical", "accident", "fire"], scenario_type),
             scenario_name=scenario["scenario_name"],
-            scenario_difficulty=difficulty,
+            scenario_difficulty=cast(Literal["easy", "medium", "hard"], difficulty),
             patient_condition=scenario["patient_condition"],
             required_specialization=scenario["required_specialization"],
             initial_critical_time_limit_minutes=scenario["critical_time_limit_minutes"],
@@ -121,7 +105,7 @@ class EmergencyEnv:
             failed_hospitals=[],
             recent_failed_hospitals=[],
             failed_reasons={},
-            total_time_spent_minutes=0,
+            total_time_spent_minutes=0.0,
             rerouting_reason=None,
             last_arrival_outcome=None,
             accepted_hospital_id=None,
@@ -136,8 +120,8 @@ class EmergencyEnv:
         )
 
         self.last_info = StepInfo(
-            task_id=resolved_task_id,
-            difficulty=difficulty,
+            task_id=cast(Literal["acde_easy", "acde_medium", "acde_hard"], resolved_task_id),
+            difficulty=cast(Literal["easy", "medium", "hard"], difficulty),
             objective=TASKS[resolved_task_id]["objective"],
             progress_score=MIN_REWARD,
             reward_model=RewardModel(
@@ -149,7 +133,12 @@ class EmergencyEnv:
                     delay_penalty=MIN_REWARD,
                 ),
             ),
-            grader=None,
+            grader=grade_task(
+                task_id=resolved_task_id,
+                difficulty=difficulty,
+                objective=TASKS[resolved_task_id]["objective"],
+                trajectory=[],
+            ),
             last_action_error=None,
             outcome=None,
         )
@@ -200,7 +189,7 @@ class EmergencyEnv:
             "medium": 0.25,
             "hard": 0.45,
         }.get(self.state_data.scenario_difficulty, 0.25)
-        dynamic_delay = self._rng.uniform(0.5, 2.5) if self._rng.random() < delay_probability else 0
+        dynamic_delay = self._rng.uniform(0.5, 2.5) if self._rng.random() < delay_probability else 0.0
         travel_time += dynamic_delay
 
         selected, travel_time, enroute_note = self._apply_enroute_diversion(selected, travel_time)
@@ -439,13 +428,13 @@ class EmergencyEnv:
         unknown_critical_penalty = (
             0.12
             if critical_patient and selected.icu_display == "unknown"
-            else 0
+            else 0.0
         )
-        repeat_penalty = 0.15 if was_visited_before else 0
-        failed_repeat_penalty = 0.20 if was_failed_before else 0
-        traffic_penalty = 0.10 if critical_patient and selected.traffic == "high" else 0.04 if critical_patient and selected.traffic == "medium" else 0
+        repeat_penalty = 0.15 if was_visited_before else 0.0
+        failed_repeat_penalty = 0.20 if was_failed_before else 0.0
+        traffic_penalty = 0.10 if critical_patient and selected.traffic == "high" else 0.04 if critical_patient and selected.traffic == "medium" else 0.0
 
-        time_bonus = 0.06 if travel_time <= 8.0 else (0.03 if travel_time <= 14.0 else 0)
+        time_bonus = 0.06 if travel_time <= 8.0 else (0.03 if travel_time <= 14.0 else 0.0)
 
         improvement_bonus = self._improvement_bonus(arrival_outcome.status)
 
@@ -470,7 +459,7 @@ class EmergencyEnv:
         )
         breakdown = RewardBreakdown(
             survival_component=max(MIN_REWARD, min(MAX_REWARD, (status_reward + 0.5) / 1.5)),
-            time_efficiency_component=max(MIN_REWARD, min(MAX_REWARD, 1 - (travel_time / 25.0))),
+            time_efficiency_component=max(MIN_REWARD, min(MAX_REWARD, 1.0 - (travel_time / 25.0))),
             specialization_component=max(MIN_REWARD, min(MAX_REWARD, MAX_REWARD if self._specialization_match(selected) else 0.4)),
             delay_penalty=max(MIN_REWARD, min(MAX_REWARD, raw_delay)),
         )
@@ -502,7 +491,7 @@ class EmergencyEnv:
         condition = self.state_data.patient_condition
         idx = CONDITION_ORDER.index(condition) if condition in CONDITION_ORDER else 2
 
-        deterioration_risk = 0
+        deterioration_risk = 0.0
         if travel_time > 12.0:
             deterioration_risk += 0.20
         if dynamic_delay > 0:
@@ -649,7 +638,7 @@ class EmergencyEnv:
             "easy": self._rng.uniform(0.4, 1.1),
             "medium": self._rng.uniform(0.8, 1.8),
             "hard": self._rng.uniform(1.2, 2.6),
-        }.get(self.state_data.scenario_difficulty, self._rng.uniform(1, 2.2))
+        }.get(self.state_data.scenario_difficulty, self._rng.uniform(1.0, 2.2))
 
         note = (
             f"Hidden case: severe traffic lock en-route to {selected.hospital_id}; "
@@ -692,7 +681,7 @@ class EmergencyEnv:
             status="rejected",
             reason="Hidden mismatch at arrival (wrong risky guess). Rerouting required.",
             validation_details=arrival_outcome.validation_details,
-            reward_modifier=0,
+            reward_modifier=0.0,
         )
         return (
             forced_reject,
@@ -770,7 +759,7 @@ class EmergencyEnv:
                 status="rejected",
                 reason=reason,
                 validation_details=new_validation,
-                reward_modifier=0,
+                reward_modifier=0.0,
             ),
             0.12,
             f"Hidden case: {reason}. Rerouting required.",
@@ -821,7 +810,7 @@ class EmergencyEnv:
                 status="rejected",
                 reason="Condition became irreversible after delays",
                 validation_details=arrival_outcome.validation_details,
-                reward_modifier=0,
+                reward_modifier=0.0,
             ),
             "Partial chain cap: condition became irreversible.",
         )
@@ -899,7 +888,7 @@ class EmergencyEnv:
                     status="rejected",
                     reason="Condition relapsed after temporary stabilization",
                     validation_details=arrival_outcome.validation_details,
-                    reward_modifier=0,
+                    reward_modifier=0.0,
                     terminal=False,
                 ),
                 "Recovery guard: partial relapsed to rejected.",
@@ -924,14 +913,14 @@ class EmergencyEnv:
     ) -> None:
         assert self.state_data is not None
 
-        grader_result = None
-        if self.state_data.done:
-            grader_result = grade_task(
-                task_id=self.state_data.task_id,
-                difficulty=self.state_data.scenario_difficulty,
-                objective=self.state_data.task_objective,
-                trajectory=self.trajectory,
-            )
+        # Always expose a bounded task score snapshot so external validators
+        # never see a missing grader and fallback to 0.0/1.0.
+        grader_result = grade_task(
+            task_id=self.state_data.task_id,
+            difficulty=self.state_data.scenario_difficulty,
+            objective=self.state_data.task_objective,
+            trajectory=self.trajectory,
+        )
 
         self.last_info = StepInfo(
             task_id=self.state_data.task_id,
@@ -1067,15 +1056,14 @@ class EmergencyEnv:
             return "medium"
         return "high"
 
-    def _sample_scenario_for_difficulty(self, difficulty: Difficulty) -> tuple[dict[str, Any], ScenarioType]:
-        generators: list[tuple[Callable[[SeededRandomizer], dict[str, Any]], ScenarioType]] = [
+    def _sample_scenario_for_difficulty(self, difficulty: str) -> tuple[dict[str, Any], str]:
+        generators = [
             (generate_medical_case, "medical"),
             (generate_accident_case, "accident"),
             (generate_fire_case, "fire"),
         ]
-        fallback_generator, fallback_type = generators[0]
-        fallback_scenario = fallback_generator(self._rng)
-
+        scenario: dict[str, Any] = {}
+        scenario_type = "medical"
         for _ in range(64):
             generator, scenario_type = self._rng.choice(generators)
             scenario = generator(self._rng)
@@ -1086,7 +1074,7 @@ class EmergencyEnv:
             scenario = generator(self._rng)
             if scenario["difficulty"] == difficulty:
                 return scenario, scenario_type
-        return fallback_scenario, fallback_type
+        return scenario, scenario_type
 
     def _find_hospital(self, hospital_id: str) -> HospitalState | None:
         assert self.state_data is not None
@@ -1115,9 +1103,9 @@ class EmergencyEnv:
 
         total = entry.success + entry.fail
         if total == 1:
-            entry.avg = _clamp(reward)
+            entry.avg = max(0.0, min(1.0, reward))
         else:
-            normalized_reward = _clamp(reward)
+            normalized_reward = max(0.0, min(1.0, reward))
             entry.avg = ((entry.avg * (total - 1)) + normalized_reward) / total
 
         memory[hospital_id] = entry
@@ -1128,26 +1116,24 @@ class EmergencyEnv:
         if not self.trajectory:
             return MIN_REWARD
         raw = sum(float(t["reward"]) for t in self.trajectory) / len(self.trajectory)
-        return _clamp(raw)
+        return max(MIN_REWARD, min(MAX_REWARD, raw))
 
     def _failure_score(self) -> float:
         assert self.state_data is not None
         progress_component = self._progress_score()
-        reward_component = _clamp(self.state_data.reward)
+        reward_component = max(MIN_REWARD, min(MAX_REWARD, self.state_data.reward))
         score = 0.15 + (0.35 * reward_component) + (0.25 * progress_component)
-        return _clamp(max(0.1, min(0.85, score)))
+        return max(MIN_REWARD, min(MAX_REWARD, max(0.1, min(0.85, score))))
 
     def _success_score(self) -> float:
         assert self.state_data is not None
         progress_component = self._progress_score()
-        reward_component = _clamp(self.state_data.reward)
+        reward_component = max(MIN_REWARD, min(MAX_REWARD, self.state_data.reward))
         total_steps = max(1, len(self.trajectory))
         rejected_steps = sum(1 for item in self.trajectory if item.get("outcome_status") == "rejected")
-        route_quality = _clamp(1 - (rejected_steps / total_steps))
+        route_quality = max(0.0, 1.0 - (rejected_steps / total_steps))
         score = (0.45 * reward_component) + (0.40 * progress_component) + (0.15 * route_quality)
-        return _clamp(max(0.25, min(0.99, score)))
+        return max(MIN_REWARD, min(MAX_REWARD, max(0.25, min(0.99, score))))
 
 
 ACDEEnvironment = EmergencyEnv
-
-

app/environment/graders.py

@@ -1,10 +1,10 @@
-from typing import Literal
+from typing import cast, Literal
 
 from app.models.reward import GraderResult
 
 
-MIN_SCORE = 0.01
-MAX_SCORE = 0.99
+MIN_SCORE = 0.001
+MAX_SCORE = 0.999
 
 
 def _norm_margin(travel_time: float, critical_limit: float) -> float:
@@ -14,8 +14,8 @@ def _norm_margin(travel_time: float, critical_limit: float) -> float:
 
 
 def grade_task(
-    task_id: Literal["acde_easy", "acde_medium", "acde_hard"],
-    difficulty: Literal["easy", "medium", "hard"],
+    task_id: str,
+    difficulty: str,
     objective: str,
     trajectory: list[dict],
 ) -> GraderResult:
@@ -27,21 +27,21 @@ def grade_task(
     
     # Count successful outcomes (accepted or partial admission)
     successful_outcomes = sum(
-        1 for t in trajectory 
+        1.0 for t in trajectory 
         if t.get("outcome_status") in ["accepted", "partial"]
     )
     success_rate = successful_outcomes / steps
     
     # Specialization match rate
     specialization_rate = sum(
-        1 for t in trajectory if t.get("specialization_match", False)
+        1.0 for t in trajectory if t.get("specialization_match", False)
     ) / steps
     
     # Time efficiency (based on travel times)
     margin_rate = sum(
-        _norm_margin(t.get("travel_time", 0), t.get("critical_limit", 1)) 
+        _norm_margin(t.get("travel_time", 0.0), t.get("critical_limit", 1.0)) 
         for t in trajectory
-    ) / steps if trajectory else 0
+    ) / steps if trajectory else 0.0
 
     # Penalty for repeated failures at same hospital
     repeat_failures = 0
@@ -55,7 +55,7 @@ def grade_task(
                 repeat_failures += 1
         visited_by_status[hospital_id] = status
 
-    repeat_failure_penalty = min(1, repeat_failures / steps)
+    repeat_failure_penalty = min(1.0, repeat_failures / steps)
 
     # Suitability component (how well hospital matched patient)
     avg_suitability = sum(
@@ -63,7 +63,7 @@ def grade_task(
     ) / steps
     
     # Adaptive penalty: worse when early rejections vs later recovery
-    adaptability_bonus = 0
+    adaptability_bonus = 0.0
     if len(trajectory) >= 2:
         outcomes = [t.get("outcome_status") for t in trajectory]
         if "rejected" in outcomes[:-1] and outcomes[-1] in ["accepted", "partial"]:
@@ -86,14 +86,14 @@ def grade_task(
         score = base
     else:  # hard
         threshold = 0.53
-        hard_bonus = 0.15 if success_rate >= 0.5 else (0.05 if success_rate > 0 else MIN_SCORE)
+        hard_bonus = 0.15 if success_rate >= 0.5 else (0.05 if success_rate > 0.0 else MIN_SCORE)
         score = min(MAX_SCORE, base + hard_bonus)
 
     score = max(MIN_SCORE, min(MAX_SCORE, score))
 
     return GraderResult(
-        task_id=task_id,
-        difficulty=difficulty,
+        task_id=cast(Literal["acde_easy", "acde_medium", "acde_hard"], task_id),
+        difficulty=cast(Literal["easy", "medium", "hard"], difficulty),
         objective=objective,
         score=score,
         passed=score >= threshold,
@@ -107,5 +107,3 @@ def grade_task(
             "threshold": threshold,
         },
     )
-
-

app/environment/validation.py

@@ -1,25 +1,15 @@
-"""Hospital validation engine for realistic arrival outcomes.
+"""Hospital validation engine for realistic arrival outcomes.
 
 Simulates hidden validation checks performed when an ambulance arrives at a hospital.
 Outcomes are based on difficulty level, hospital capacity, patient suitability, and randomness.
 """
 
-from typing import Literal
+from typing import cast, Literal
 
 from app.models.state import ArrivalOutcome, HospitalValidationDetails, HospitalState
 from app.utils.randomizer import SeededRandomizer
 
 
-STRICT_SCORE_MIN = 0.01
-STRICT_SCORE_MAX = 0.99
-OverloadStatus = Literal["clear", "moderate", "severe"]
-OutcomeStatus = Literal["accepted", "partial", "rejected"]
-
-
-def _clamp(value: float) -> float:
-    return max(STRICT_SCORE_MIN, min(STRICT_SCORE_MAX, float(value)))
-
-
 class HospitalValidator:
     """Performs hidden validation checks on arrival and returns outcome."""
 
@@ -76,7 +66,7 @@ class HospitalValidator:
             icu_available=icu_available,
             doctor_available=doctor_available,
             equipment_functional=equipment_functional,
-            overload_status=overload_status,
+            overload_status=cast(Literal["clear", "moderate", "severe"], overload_status),
             patient_suitability=patient_suitability,
         )
         
@@ -91,7 +81,7 @@ class HospitalValidator:
         )
         
         return ArrivalOutcome(
-            status=status,
+            status=cast(Literal["accepted", "partial", "rejected"], status),
             reason=reason,
             validation_details=validation_details,
             reward_modifier=reward_modifier,
@@ -107,11 +97,11 @@ class HospitalValidator:
         }.get(difficulty, 0.70)
 
         # Displayed status influences belief but does not fully determine truth.
-        display_adjust = 0
+        display_adjust = 0.0
         if hospital.icu_display == "available":
             display_adjust = 0.06 if difficulty == "easy" else (0.04 if difficulty == "medium" else 0.02)
         else:  # unknown
-            display_adjust = -0.03 if difficulty == "easy" else (-0.02 if difficulty == "medium" else 0)
+            display_adjust = -0.03 if difficulty == "easy" else (-0.02 if difficulty == "medium" else 0.0)
 
         p = max(0.05, min(0.97, base_true_prob + display_adjust))
         return self.rng.random() < p
@@ -142,7 +132,7 @@ class HospitalValidator:
         }.get(difficulty, 0.90)
         return self.rng.random() < equipment_working_prob
 
-    def _check_hospital_overload(self, difficulty: str) -> OverloadStatus:
+    def _check_hospital_overload(self, difficulty: str) -> str:
         """Determine hospital overload status: clear, moderate, or severe."""
         overload_prob = {
             "easy": 0.10,
@@ -164,11 +154,11 @@ class HospitalValidator:
         hospital: HospitalState,
         patient_condition: str,
         required_specialization: str,
-        overload_status: OverloadStatus,
+        overload_status: str,
         difficulty: str,
     ) -> float:
         """
-        Compute how suitable this hospital is for the patient (0 to 1).
+        Compute how suitable this hospital is for the patient (0.0 to 1.0).
         Based on specialization match, condition severity, and overload.
         """
         # Specialization match basis
@@ -190,7 +180,7 @@ class HospitalValidator:
         
         # Hospital overload impact
         overload_impact = {
-            "clear": 1,
+            "clear": 1.0,
             "moderate": 0.7,
             "severe": 0.4,
         }
@@ -202,9 +192,9 @@ class HospitalValidator:
         # Add difficulty-based noise
         if difficulty == "hard":
             noise = self.rng.uniform(-0.15, 0.15)
-            suitability = _clamp(suitability + noise)
+            suitability = max(0.0, min(1.0, suitability + noise))
         
-        return _clamp(suitability)
+        return suitability
 
     def _determine_outcome(
         self,
@@ -215,7 +205,7 @@ class HospitalValidator:
         specialization_match: bool,
         difficulty: str,
         step_number: int,
-    ) -> tuple[OutcomeStatus, str, float, bool]:
+    ) -> tuple[str, str, float, bool]:
         """
         Determine final outcome (accepted, partial, or rejected) based on validation.
         
@@ -281,7 +271,7 @@ class HospitalValidator:
             return (
                 "rejected",
                 f"Hospital cannot admit: {', '.join(rejection_reasons[:2])}",
-                0,
+                0.0,
                 False,
             )
         
@@ -357,7 +347,7 @@ class HospitalValidator:
                 return (
                     "rejected",
                     "Condition became non-transferable during delay; immediate critical care failed",
-                    0,
+                    0.0,
                     True,
                 )
 
@@ -369,14 +359,14 @@ class HospitalValidator:
             )
         
         # Full acceptance
-        confidence_bonus = 1
+        confidence_bonus = 1.0
         if validation.patient_suitability >= 0.8:
             confidence_bonus = 1.1
         elif validation.patient_suitability >= 0.7:
             confidence_bonus = 1.05
 
         # Arrival uncertainty by difficulty.
-        reject_prob = 0
+        reject_prob = 0.0
         if difficulty == "medium":
             reject_prob = 0.2
         elif difficulty == "hard":
@@ -384,11 +374,11 @@ class HospitalValidator:
             reject_prob += 0.10
             reject_prob += 0.08
 
-        if reject_prob > 0 and self.rng.random() < reject_prob:
+        if reject_prob > 0.0 and self.rng.random() < reject_prob:
             return (
                 "rejected",
                 "Unexpected complication at arrival",
-                0,
+                0.0,
                 False,
             )
 
@@ -396,7 +386,7 @@ class HospitalValidator:
             return (
                 "accepted",
                 "successful admission under uncertainty",
-                1,
+                1.0,
                 False,
             )
         
@@ -412,7 +402,7 @@ class HospitalValidator:
                     False,
                 )
 
-        accepted_prob = 1
+        accepted_prob = 1.0
         if difficulty == "hard":
             accepted_prob *= 0.65
         if self.rng.random() > accepted_prob:
@@ -437,7 +427,7 @@ class DifficultyModifier:
     @staticmethod
     def get_icu_mismatch_probability(difficulty: str) -> float:
         """Probability of hidden ICU mismatch (shown vs actual)."""
-        return {"easy": 0, "medium": 0.15, "hard": 0.35}.get(difficulty, 0.15)
+        return {"easy": 0.0, "medium": 0.15, "hard": 0.35}.get(difficulty, 0.15)
 
     @staticmethod
     def get_unexpected_event_probability(difficulty: str) -> float:
@@ -447,11 +437,9 @@ class DifficultyModifier:
     @staticmethod
     def get_minimum_survival_probability(difficulty: str) -> float:
         """Floor below which patient won't survive regardless."""
-        return {"easy": 0.05, "medium": 0.02, "hard": 0}.get(difficulty, 0.02)
+        return {"easy": 0.05, "medium": 0.02, "hard": 0.0}.get(difficulty, 0.02)
 
     @staticmethod
     def get_initial_condition_variance(difficulty: str) -> float:
         """How much patient condition can vary initially."""
-        return {"easy": 0, "medium": 0.1, "hard": 0.25}.get(difficulty, 0.1)
-
-
+        return {"easy": 0.0, "medium": 0.1, "hard": 0.25}.get(difficulty, 0.1)

app/models/observation.py

@@ -1,14 +1,6 @@
-from typing import Literal
+from typing import Literal
 
-from pydantic import BaseModel, Field, field_validator
-
-
-_FLOOR = 0.01
-_CEIL = 0.99
-
-
-def _clamp(v: float) -> float:
-    return max(_FLOOR, min(_CEIL, float(v)))
+from pydantic import BaseModel, Field
 
 
 class HospitalObservation(BaseModel):
@@ -23,12 +15,7 @@ class ArrivalOutcomeObservation(BaseModel):
     """What happened when ambulance arrived at hospital"""
     status: Literal["accepted", "partial", "rejected"]
     reason: str
-    suitability_score: float = Field(ge=_FLOOR, le=_CEIL)
-
-    @field_validator("suitability_score", mode="before")
-    @classmethod
-    def clamp_suitability(cls, v: float) -> float:
-        return _clamp(v)
+    suitability_score: float = Field(ge=0.0, le=1.0)
 
 
 class Observation(BaseModel):
@@ -54,11 +41,9 @@ class Observation(BaseModel):
     failed_hospitals: list[str] = Field(default_factory=list)
     recent_failed_hospitals: list[str] = Field(default_factory=list)
     failed_reasons: dict[str, str] = Field(default_factory=dict)
-    total_time_spent_minutes: float = Field(default=0, ge=0)
+    total_time_spent_minutes: float = Field(default=0.0, ge=0.0)
     rerouting_reason: str | None = None
     # New fields for arrival outcome visibility
     last_arrival_outcome: ArrivalOutcomeObservation | None = None
     explanation: list[str] = Field(default_factory=list)
     memory_snapshot: dict[str, dict[str, float | int]] = Field(default_factory=dict)
-
-

app/models/reward.py

@@ -1,75 +1,73 @@
-from typing import Literal
-
-from pydantic import BaseModel, Field, field_validator
-
-
-# Strict boundaries for all score-like fields.
-# The external validator requires scores strictly between 0 and 1
-# (not 0 and not 1), so we clamp all values to [0.01, 0.99].
-_FLOOR = 0.01
-_CEIL = 0.99
-
-
-def _clamp(v: float) -> float:
-    """Clamp a score to the open interval (0, 1)."""
-    return max(_FLOOR, min(_CEIL, v))
-
-
-class RewardBreakdown(BaseModel):
-    survival_component: float = Field(ge=_FLOOR, le=_CEIL)
-    time_efficiency_component: float = Field(ge=_FLOOR, le=_CEIL)
-    specialization_component: float = Field(ge=_FLOOR, le=_CEIL)
-    delay_penalty: float = Field(ge=_FLOOR, le=_CEIL)
-
-    @field_validator(
-        "survival_component",
-        "time_efficiency_component",
-        "specialization_component",
-        "delay_penalty",
-        mode="before",
-    )
-    @classmethod
-    def clamp_score(cls, v: float) -> float:
-        return _clamp(v)
-
-
-class RewardModel(BaseModel):
-    value: float = Field(ge=_FLOOR, le=_CEIL)
-    breakdown: RewardBreakdown
-
-    @field_validator("value", mode="before")
-    @classmethod
-    def clamp_value(cls, v: float) -> float:
-        return _clamp(v)
-
-
-class GraderResult(BaseModel):
-    task_id: Literal["acde_easy", "acde_medium", "acde_hard"]
-    difficulty: Literal["easy", "medium", "hard"]
-    objective: str
-    score: float = Field(ge=_FLOOR, le=_CEIL)
-    passed: bool
-    criteria: dict[str, float] = Field(default_factory=dict)
-
-    @field_validator("score", mode="before")
-    @classmethod
-    def clamp_score(cls, v: float) -> float:
-        return _clamp(v)
-
-
-class StepInfo(BaseModel):
-    last_action_error: str | None = None
-    task_id: Literal["acde_easy", "acde_medium", "acde_hard"]
-    difficulty: Literal["easy", "medium", "hard"]
-    objective: str
-    progress_score: float = Field(ge=_FLOOR, le=_CEIL)
-    reward_model: RewardModel
-    grader: GraderResult | None = None
-    outcome: dict[str, str] | None = None
-
-    @field_validator("progress_score", mode="before")
-    @classmethod
-    def clamp_progress(cls, v: float) -> float:
-        return _clamp(v)
-
-
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+
+# Strict boundaries for all score-like fields.
+# The external validator requires scores strictly between 0 and 1
+# (not 0.0 and not 1.0), so we clamp all values to [0.001, 0.999].
+_FLOOR = 0.001
+_CEIL = 0.999
+
+
+def _clamp(v: float) -> float:
+    """Clamp a score to the open interval (0, 1)."""
+    return max(_FLOOR, min(_CEIL, v))
+
+
+class RewardBreakdown(BaseModel):
+    survival_component: float = Field(ge=_FLOOR, le=_CEIL)
+    time_efficiency_component: float = Field(ge=_FLOOR, le=_CEIL)
+    specialization_component: float = Field(ge=_FLOOR, le=_CEIL)
+    delay_penalty: float = Field(ge=_FLOOR, le=_CEIL)
+
+    @field_validator(
+        "survival_component",
+        "time_efficiency_component",
+        "specialization_component",
+        "delay_penalty",
+        mode="before",
+    )
+    @classmethod
+    def clamp_score(cls, v: float) -> float:
+        return _clamp(v)
+
+
+class RewardModel(BaseModel):
+    value: float = Field(ge=_FLOOR, le=_CEIL)
+    breakdown: RewardBreakdown
+
+    @field_validator("value", mode="before")
+    @classmethod
+    def clamp_value(cls, v: float) -> float:
+        return _clamp(v)
+
+
+class GraderResult(BaseModel):
+    task_id: Literal["acde_easy", "acde_medium", "acde_hard"]
+    difficulty: Literal["easy", "medium", "hard"]
+    objective: str
+    score: float = Field(ge=_FLOOR, le=_CEIL)
+    passed: bool
+    criteria: dict[str, float] = Field(default_factory=dict)
+
+    @field_validator("score", mode="before")
+    @classmethod
+    def clamp_score(cls, v: float) -> float:
+        return _clamp(v)
+
+
+class StepInfo(BaseModel):
+    last_action_error: str | None = None
+    task_id: Literal["acde_easy", "acde_medium", "acde_hard"]
+    difficulty: Literal["easy", "medium", "hard"]
+    objective: str
+    progress_score: float = Field(ge=_FLOOR, le=_CEIL)
+    reward_model: RewardModel
+    grader: GraderResult | None = None
+    outcome: dict[str, str] | None = None
+
+    @field_validator("progress_score", mode="before")
+    @classmethod
+    def clamp_progress(cls, v: float) -> float:
+        return _clamp(v)

app/models/state.py

@@ -1,28 +1,15 @@
-from typing import Literal
+from typing import Literal
 
-from pydantic import BaseModel, Field, field_validator
-
-
-_FLOOR = 0.01
-_CEIL = 0.99
-
-
-def _clamp(v: float) -> float:
-    return max(_FLOOR, min(_CEIL, float(v)))
+from pydantic import BaseModel, Field
 
 
 class LearningEntry(BaseModel):
     success: int = Field(default=0, ge=0)
     fail: int = Field(default=0, ge=0)
-    avg: float = Field(default=_FLOOR, ge=_FLOOR, le=_CEIL)
+    avg: float = Field(default=0.0, ge=0.0, le=1.0)
     accepted: int = Field(default=0, ge=0)
     rejected: int = Field(default=0, ge=0)
 
-    @field_validator("avg", mode="before")
-    @classmethod
-    def clamp_avg(cls, v: float) -> float:
-        return _clamp(v)
-
 
 class HospitalValidationDetails(BaseModel):
     """Hidden validation checks performed after ambulance arrives at hospital"""
@@ -30,12 +17,7 @@ class HospitalValidationDetails(BaseModel):
     doctor_available: bool
     equipment_functional: bool
     overload_status: Literal["clear", "moderate", "severe"]
-    patient_suitability: float = Field(ge=_FLOOR, le=_CEIL)  # 0=unsuitable, 1=ideal
-
-    @field_validator("patient_suitability", mode="before")
-    @classmethod
-    def clamp_suitability(cls, v: float) -> float:
-        return _clamp(v)
+    patient_suitability: float = Field(ge=0.0, le=1.0)  # 0=unsuitable, 1=ideal
 
 
 class ArrivalOutcome(BaseModel):
@@ -43,7 +25,7 @@ class ArrivalOutcome(BaseModel):
     status: Literal["accepted", "partial", "rejected"]
     reason: str
     validation_details: HospitalValidationDetails | None = None
-    reward_modifier: float = Field(default=1, ge=0, le=1.5)
+    reward_modifier: float = Field(default=1.0, ge=0.0, le=1.5)
     terminal: bool = False
 
 
@@ -74,20 +56,18 @@ class EnvState(BaseModel):
     selected_hospital_id: str | None = None
     done: bool = False
     final_outcome: Literal["SUCCESS", "FAILURE"] | None = None
-    final_score: float = Field(default=_FLOOR, ge=_FLOOR, le=_CEIL)
-    reward: float = Field(default=_FLOOR, ge=_FLOOR, le=_CEIL)
+    final_score: float = Field(default=0.001, ge=0.001, le=0.999)
+    reward: float = Field(default=0.001, ge=0.001, le=0.999)
     ambulance_status: Literal["en_route", "in_transit", "arrived", "admitted", "rerouting"] = "en_route"
     current_location_context: str = "incident_site"
     visited_hospitals: list[str] = Field(default_factory=list)
     failed_hospitals: list[str] = Field(default_factory=list)
     recent_failed_hospitals: list[str] = Field(default_factory=list)
     failed_reasons: dict[str, str] = Field(default_factory=dict)
-    total_time_spent_minutes: float = Field(default=0, ge=0)
+    total_time_spent_minutes: float = Field(default=0.0, ge=0.0)
     rerouting_reason: str | None = None
     # New fields for arrival tracking
     last_arrival_outcome: ArrivalOutcome | None = None
     accepted_hospital_id: str | None = None
     explanation: list[str] = Field(default_factory=list)
     memory: dict[str, LearningEntry] = Field(default_factory=dict)
-
-

app/server/app.py

@@ -1,4 +1,4 @@
-from pathlib import Path
+from pathlib import Path
 
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
@@ -6,15 +6,15 @@ from pydantic import BaseModel
 from app.environment.core import ACDEEnvironment
 from app.models.action import Action
 from app.models.observation import Observation
-from app.models.reward import StepInfo
+from app.models.reward import StepInfo, GraderResult, RewardModel, RewardBreakdown
 from app.models.state import EnvState
 
 ROOT = Path(__file__).resolve().parents[2]
 MEMORY_FILE = ROOT / "data" / "learning_memory.json"
 
-app = FastAPI(title="Adaptive Crisis Decision Environment", version="1")
+app = FastAPI(title="Adaptive Crisis Decision Environment", version="1.0.0")
 env = ACDEEnvironment(memory_file=str(MEMORY_FILE))
-MIN_REWARD = 0.01
+MIN_REWARD = 0.001
 
 
 class ResetRequest(BaseModel):
@@ -55,9 +55,7 @@ def reset(payload: ResetRequest | None = None) -> StepResponse:
     seed = payload.seed if payload else None
     task_id = payload.task_id if payload else None
     obs = env.reset(seed=seed, task_id=task_id)
-    info = env.last_info
-    if info is None:
-        raise HTTPException(status_code=500, detail="Internal error: missing step info after reset")
+    info = env.last_info if env.last_info else StepInfo(task_id="acde_medium", difficulty="medium", objective="", progress_score=MIN_REWARD, reward_model=RewardModel(value=MIN_REWARD, breakdown=RewardBreakdown(survival_component=MIN_REWARD, time_efficiency_component=MIN_REWARD, specialization_component=MIN_REWARD, delay_penalty=MIN_REWARD)), grader=GraderResult(task_id="acde_medium", difficulty="medium", objective="", score=MIN_REWARD, passed=False, criteria={}), last_action_error=None, outcome=None)
     return StepResponse(observation=obs, reward=MIN_REWARD, done=False, info=info)
 
 
@@ -67,20 +65,14 @@ def step(action: Action) -> StepResponse:
         result = env.step(action)
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
-    info = env.last_info
-    if info is None:
-        raise HTTPException(status_code=500, detail="Internal error: missing step info after step")
-
     return StepResponse(
         observation=result["observation"],
         reward=float(result["reward"]),
         done=bool(result["done"]),
-        info=info,
+        info=result.get("info", {}),
     )
 
 
 @app.get("/state", response_model=EnvState)
 def state() -> EnvState:
     return env.state()
-
-

app/utils/calculations.py

@@ -1,14 +1,7 @@
-from app.models.state import LearningEntry
-
-STRICT_SCORE_MIN = 0.01
-STRICT_SCORE_MAX = 0.99
-
-
-def _clamp(value: float) -> float:
-    return max(STRICT_SCORE_MIN, min(STRICT_SCORE_MAX, float(value)))
+from app.models.state import LearningEntry
 
 TRAFFIC_FACTOR = {
-    "low": 1,
+    "low": 1.0,
     "medium": 0.6,
     "high": 0.3,
 }
@@ -25,7 +18,7 @@ def compute_travel_time_minutes(distance_km: float, speed_kmh: float) -> float:
 
 
 def score_distance(distance_km: float, max_distance_km: float = 20.0) -> float:
-    return _clamp(1 - (distance_km / max_distance_km))
+    return max(0.0, min(1.0, 1.0 - (distance_km / max_distance_km)))
 
 
 def score_traffic(traffic: str) -> float:
@@ -33,7 +26,7 @@ def score_traffic(traffic: str) -> float:
 
 
 def score_icu(display_icu: str) -> float:
-    return _clamp(1 if display_icu == "available" else 0.55)
+    return 1.0 if display_icu == "available" else 0.55
 
 
 def score_memory(entry: LearningEntry | None) -> float:
@@ -43,9 +36,9 @@ def score_memory(entry: LearningEntry | None) -> float:
     if total == 0:
         return 0.5
     success_rate = entry.success / total
-    fail_bias = max(0, (entry.fail - entry.success) / total)
+    fail_bias = max(0.0, (entry.fail - entry.success) / total)
     raw = (0.7 * entry.avg) + (0.3 * success_rate) - (0.4 * fail_bias)
-    return _clamp(raw)
+    return max(0.0, min(1.0, raw))
 
 
 def decision_score(
@@ -60,7 +53,7 @@ def decision_score(
         + (traffic_score * 0.2)
         + (memory_score * 0.3)
     )
-    return _clamp(weighted / 1.2)
+    return max(0.0, min(1.0, weighted / 1.2))
 
 
 def compute_reward(
@@ -69,10 +62,10 @@ def compute_reward(
     critical_limit: float,
     specialization_match: bool,
 ) -> float:
-    survival_component = _clamp(1 if survived else 0)
-    time_efficiency = _clamp(critical_limit / max(critical_limit + travel_time, 1e-6))
-    specialization_component = _clamp(1 if specialization_match else 0)
-    delay_penalty = _clamp(travel_time / max(critical_limit + travel_time, 1e-6))
+    survival_component = 1.0 if survived else 0.0
+    time_efficiency = max(0.0, min(1.0, critical_limit / max(critical_limit + travel_time, 1e-6)))
+    specialization_component = 1.0 if specialization_match else 0.0
+    delay_penalty = max(0.0, min(1.0, travel_time / max(critical_limit + travel_time, 1e-6)))
 
     reward = (
         (survival_component * 0.45)
@@ -80,7 +73,7 @@ def compute_reward(
         + (specialization_component * 0.2)
         - (delay_penalty * 0.1)
     )
-    return _clamp(reward)
+    return max(0.0, min(1.0, reward))
 
 
 def compute_reward_with_breakdown(
@@ -93,19 +86,19 @@ def compute_reward_with_breakdown(
     adaptability_score: float | None = None,
 ) -> tuple[float, dict[str, float]]:
     survival_component = (
-        _clamp(survival_score)
+        max(0.0, min(1.0, survival_score))
         if survival_score is not None
-        else _clamp(1 if survived else 0)
+        else (1.0 if survived else 0.0)
     )
-    time_efficiency = _clamp(critical_limit / max(critical_limit + travel_time, 1e-6))
+    time_efficiency = max(0.0, min(1.0, critical_limit / max(critical_limit + travel_time, 1e-6)))
     specialization_component = (
-        _clamp(capability_score)
+        max(0.0, min(1.0, capability_score))
         if capability_score is not None
-        else _clamp(1 if specialization_match else 0)
+        else (1.0 if specialization_match else 0.0)
     )
-    delay_penalty = _clamp(travel_time / max(critical_limit + travel_time, 1e-6))
+    delay_penalty = max(0.0, min(1.0, travel_time / max(critical_limit + travel_time, 1e-6)))
     adapt_component = (
-        _clamp(adaptability_score)
+        max(0.0, min(1.0, adaptability_score))
         if adaptability_score is not None
         else 0.5
     )
@@ -117,12 +110,10 @@ def compute_reward_with_breakdown(
         + (adapt_component * 0.2)
         - (delay_penalty * 0.12)
     )
-    reward = _clamp(reward)
+    reward = max(0.0, min(1.0, reward))
     return reward, {
         "survival_component": survival_component,
         "time_efficiency_component": time_efficiency,
         "specialization_component": specialization_component,
         "delay_penalty": delay_penalty,
     }
-
-

client.py

@@ -1,4 +1,4 @@
-"""OpenEnv client for the Adaptive Crisis Decision Environment."""
+"""OpenEnv client for the Adaptive Crisis Decision Environment."""
 
 from typing import Dict
 
@@ -33,7 +33,7 @@ class ACDEEnv(EnvClient[ACDEAction, ACDEObservation]):
 
         return StepResult(
             observation=observation,
-            reward=payload.get("reward", 0),
+            reward=payload.get("reward", 0.0),
             done=payload.get("done", False),
         )
 
@@ -41,4 +41,4 @@ class ACDEEnv(EnvClient[ACDEAction, ACDEObservation]):
         return State(
             episode_id=payload.get("episode_id"),
             step_count=payload.get("step", 0),
-        )
+        )

inference.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python3
 """Local agent runner for EmergencyEnv.
 
 This script acts as an agent only:
@@ -17,21 +17,21 @@ import os
 import random
 from pathlib import Path
 from datetime import datetime, timezone
-from typing import Any
+from typing import Union, TYPE_CHECKING, Optional, cast
 
 from app.environment.core import EmergencyEnv
 from app.models.action import Action
 
+if TYPE_CHECKING:
+    from openai import OpenAI as OpenAIClient
+else:
+    OpenAIClient = None
+
 try:
     from openai import OpenAI
 except Exception:  # pragma: no cover - fallback for missing optional dependency
     OpenAI = None
 
-try:
-    from huggingface_hub import get_token as hf_get_token
-except Exception:  # pragma: no cover - optional fallback for cached HF auth
-    hf_get_token = None
-
 TASK_ORDER = ["acde_easy", "acde_medium", "acde_hard"]
 LEVEL_TO_TASK = {
     "low": "acde_easy",
@@ -41,14 +41,14 @@ LEVEL_TO_TASK = {
 RANDOM_LEVELS = ("medium", "high")
 RANDOM_LEVEL_WEIGHTS = (0.25, 0.75)
 BASE_SPEED_KMH = 60.0
-TRAFFIC_FACTOR = {"low": 1, "medium": 0.6, "high": 0.3}
+TRAFFIC_FACTOR = {"low": 1.0, "medium": 0.6, "high": 0.3}
 LEARNING_ARCHIVE_PATH = Path(__file__).resolve().parent / "data" / "learning_archive.json"
 LEARNING_ARCHIVE_VERSION = 2
 DEFAULT_API_BASE_URL = "https://api-inference.huggingface.co/v1"
 DEFAULT_MODEL_NAME = "Qwen/Qwen2.5-72B-Instruct"
 REQUIRED_ENV_VARS = ("HF_TOKEN",)
-STRICT_SCORE_MIN = 0.01
-STRICT_SCORE_MAX = 0.99
+STRICT_SCORE_MIN = 0.001
+STRICT_SCORE_MAX = 0.999
 
 
 def clamp_strict_score(value: float) -> float:
@@ -56,11 +56,6 @@ def clamp_strict_score(value: float) -> float:
     return max(STRICT_SCORE_MIN, min(STRICT_SCORE_MAX, float(value)))
 
 
-def safe_score(value: float) -> float:
-    """Normalize a score before emitting or persisting it."""
-    return round(clamp_strict_score(value), 6)
-
-
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="EmergencyEnv agent runner")
     parser.add_argument("--mode", choices=["single", "full"], default="full")
@@ -82,32 +77,20 @@ def emit_structured(tag: str, payload: dict) -> None:
 
 
 def runtime_llm_config() -> dict[str, str]:
-    hf_token = os.getenv("HF_TOKEN", "").strip()
-    if not hf_token and hf_get_token is not None:
-        try:
-            hf_token = (hf_get_token() or "").strip()
-        except Exception:
-            hf_token = ""
-
     return {
         "API_BASE_URL": os.getenv("API_BASE_URL", DEFAULT_API_BASE_URL).strip(),
         "MODEL_NAME": os.getenv("MODEL_NAME", DEFAULT_MODEL_NAME).strip(),
-        "HF_TOKEN": hf_token,
+        "HF_TOKEN": os.getenv("HF_TOKEN", "").strip(),
     }
 
 
-def require_llm_config() -> tuple[object, str]:
+def require_llm_config() -> tuple[OpenAIClient, str]:
     config = runtime_llm_config()
     missing = [name for name, value in config.items() if not value]
     if missing:
-        missing_message = ", ".join(missing)
-        if missing_message == "HF_TOKEN":
-            raise SystemExit(
-                "Missing Hugging Face token. Set HF_TOKEN or run `hf auth login` before running inference.py"
-            )
         raise SystemExit(
             "Missing required environment variables: "
-            + missing_message
+            + ", ".join(missing)
             + ". Set HF_TOKEN before running inference.py"
         )
     if OpenAI is None:
@@ -118,7 +101,7 @@ def require_llm_config() -> tuple[object, str]:
 
 
 def llm_rationale(
-    client: Any,
+    client: Union[OpenAIClient, None],
     model_name: str,
     observation: dict,
     chosen: dict,
@@ -128,6 +111,8 @@ def llm_rationale(
         f"Selected {chosen['hospital_id']} by {strategy}; "
         f"score={chosen['policy_score']:.3f}, traffic={chosen['traffic']}, icu={chosen['icu']}"
     )
+    if client is None:
+        return fallback
     try:
         prompt = (
             "You are an emergency routing agent. Return one short sentence rationale "
@@ -145,7 +130,7 @@ def llm_rationale(
                 {"role": "system", "content": "Generate concise emergency triage rationale."},
                 {"role": "user", "content": prompt},
             ],
-            temperature=0,
+            temperature=0.0,
             max_tokens=60,
         )
         text = (completion.choices[0].message.content or "").strip()
@@ -246,7 +231,7 @@ def _merge_step_stats(primary: dict, secondary: dict) -> dict:
             accepted = int(a.get("accepted", 0)) + int(b.get("accepted", 0))
             partial = int(a.get("partial", 0)) + int(b.get("partial", 0))
             rejected = int(a.get("rejected", 0)) + int(b.get("rejected", 0))
-            total_reward = float(a.get("total_reward", 0)) + float(b.get("total_reward", 0))
+            total_reward = float(a.get("total_reward", 0.0)) + float(b.get("total_reward", 0.0))
             merged[step_key][hospital_id] = {
                 "count": count,
                 "success": int(a.get("success", 0)) + int(b.get("success", 0)),
@@ -277,7 +262,7 @@ def build_learning_profile(
     # Strict scope: learn only from same seed + same level/task.
     return {
         "attempts": int(exact.get("attempts", 0)),
-        "best_score": float(exact.get("best_score", 0)),
+        "best_score": float(exact.get("best_score", 0.0)),
         "best_actions": list(exact.get("best_actions", [])),
         "step_stats": exact.get("step_stats", {}),
         "best_scenario_name": exact.get("best_scenario_name"),
@@ -302,7 +287,7 @@ def _sample_softmax(candidates: list[dict], key: str, temperature: float, rng: r
     probs = [e / total for e in exps]
 
     roll = rng.random()
-    cdf = 0
+    cdf = 0.0
     for item, prob in zip(candidates, probs):
         cdf += prob
         if roll <= cdf:
@@ -322,7 +307,7 @@ def memory_score_for_hospital(
 
     success = int(entry.get("accepted", entry.get("success", 0)))
     fail = int(entry.get("rejected", entry.get("fail", 0)))
-    avg = float(entry.get("avg", 0))
+    avg = float(entry.get("avg", 0.0))
     total = success + fail
     if total <= 0:
         return 0.5
@@ -336,8 +321,8 @@ def memory_score_for_hospital(
         step_stats = learning_profile.get("step_stats", {}).get(str(step_number), {})
         hospital_stats = step_stats.get(hospital_id)
         if hospital_stats:
-            step_avg = float(hospital_stats.get("avg_reward", 0))
-            step_success = float(hospital_stats.get("success_rate", 0))
+            step_avg = float(hospital_stats.get("avg_reward", 0.0))
+            step_success = float(hospital_stats.get("success_rate", 0.0))
             step_count = int(hospital_stats.get("count", 0))
             value += min(0.20, (step_avg * 0.10) + (step_success * 0.08) + min(step_count, 5) * 0.01)
             recent_failed = str(hospital_stats.get("last_status", "")).upper() == "REJECTED"
@@ -345,7 +330,7 @@ def memory_score_for_hospital(
     if recent_failed:
         value -= 0.3
 
-    return clamp_strict_score(value)
+    return max(0.0, min(1.0, value))
 
 
 def score_hospitals(observation: dict, learning_profile: dict | None = None) -> list[dict]:
@@ -360,7 +345,7 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
     scored: list[dict] = []
     initial_limit = float(observation.get("initial_critical_time_limit_minutes", observation["critical_time_limit_minutes"]))
     remaining_time = float(observation.get("remaining_time_minutes", observation["critical_time_limit_minutes"]))
-    urgency = 1 - min(1, max(0, remaining_time / max(initial_limit, 1e-6)))
+    urgency = 1.0 - min(1.0, max(0.0, remaining_time / max(initial_limit, 1e-6)))
 
     patient_condition = observation.get("patient_condition", "").lower()
     critical_patient = patient_condition in {"critical", "unstable"}
@@ -378,8 +363,8 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
         speed_kmh = BASE_SPEED_KMH * traffic_factor
         travel_time = (hospital["distance_km"] / max(speed_kmh, 1e-6)) * 60.0
 
-        distance_score = clamp_strict_score(1 - hospital["distance_km"] / 20.0)
-        icu_score = clamp_strict_score(1 if hospital["icu"] == "available" else 0.55)
+        distance_score = max(0.0, min(1.0, 1.0 - hospital["distance_km"] / 20.0))
+        icu_score = 1.0 if hospital["icu"] == "available" else 0.55
         mem_score = memory_score_for_hospital(
             hospital["hospital_id"],
             memory_snapshot,
@@ -408,24 +393,24 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
             and observation["required_specialization"] != "general"
         )
 
-        rejected_penalty = 0.40 if hospital["hospital_id"] in failed else 0
-        revisit_penalty = 0.14 if hospital["hospital_id"] in visited else 0
+        rejected_penalty = 0.40 if hospital["hospital_id"] in failed else 0.0
+        revisit_penalty = 0.14 if hospital["hospital_id"] in visited else 0.0
         partial_repeat_penalty = (
             0.32
             if last_status == "partial" and hospital["hospital_id"] == previous_action
-            else 0
+            else 0.0
         )
         critical_unknown_penalty = 0.17 if critical_patient and hospital["icu"] == "unknown" else 0.03
-        traffic_penalty = 0.10 if hospital["traffic"] == "high" else 0.04 if hospital["traffic"] == "medium" else 0
+        traffic_penalty = 0.10 if hospital["traffic"] == "high" else 0.04 if hospital["traffic"] == "medium" else 0.0
         if critical_patient and general_fallback:
             spec_penalty = {"easy": 0.08, "medium": 0.16, "hard": 0.26}.get(difficulty, 0.16)
             if attempts >= 5:
                 spec_penalty += 0.06
         else:
-            spec_penalty = 0
-        spec_bonus = 0.16 if exact_spec_match else (0.08 if spec_match else 0)
-        urgency_boost = urgency * (0.18 + max(0, 0.25 - travel_time / 100.0))
-        step_route_bonus = 0
+            spec_penalty = 0.0
+        spec_bonus = 0.16 if exact_spec_match else (0.08 if spec_match else 0.0)
+        urgency_boost = urgency * (0.18 + max(0.0, 0.25 - travel_time / 100.0))
+        step_route_bonus = 0.0
         if step_number - 1 < len(preferred_route) and preferred_route[step_number - 1] == hospital["hospital_id"]:
             step_route_bonus = 0.16
 
@@ -468,7 +453,7 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
             score -= 0.3
 
         # Confidence-style risk multiplier keeps risky options from looking deceptively good.
-        risk_factor = 1
+        risk_factor = 1.0
         if hospital["icu"] == "unknown":
             risk_factor *= 0.6
         if not spec_match:
@@ -484,13 +469,13 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
             memory_weight = 0.1
             current_score_weight = 0.9
         base_current_score = score
-        confidence_score = clamp_strict_score(base_current_score)
+        confidence_score = max(0.0, min(1.0, base_current_score))
         effective_memory_score = mem_score
         in_best_route = hospital["hospital_id"] in preferred_route
         if in_best_route and confidence_score < 0.6:
-            effective_memory_score = STRICT_SCORE_MIN
+            effective_memory_score = 0.0
         if confidence_score < 0.2:
-            effective_memory_score = STRICT_SCORE_MIN
+            effective_memory_score = 0.0
 
         score = (current_score_weight * base_current_score) + (memory_weight * effective_memory_score)
 
@@ -503,13 +488,13 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
                 "specialization": hospital["specialization"],
                 "travel_time": travel_time,
                 "memory_score": mem_score,
-                "policy_score": clamp_strict_score(score),
+                "policy_score": max(0.0, min(1.0, score)),
                 "specialization_match": spec_match,
                 "tie_break_score": (
                     (distance_score * 0.35)
                     + (traffic_factor * 0.35)
                     + (icu_score * 0.20)
-                    + (0.10 if spec_match else 0)
+                    + (0.10 if spec_match else 0.0)
                 ),
             }
         )
@@ -530,7 +515,7 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
                     )
                     jitter_rng = random.Random(jitter_seed)
                     normalized *= jitter_rng.uniform(0.3, 0.7)
-                item["policy_score"] = clamp_strict_score(normalized)
+                item["policy_score"] = max(0.0, min(1.0, normalized))
         elif max_score > 0:
             for item in scored:
                 normalized = item["policy_score"] / max_score
@@ -542,14 +527,14 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
                     )
                     jitter_rng = random.Random(jitter_seed)
                     normalized *= jitter_rng.uniform(0.3, 0.7)
-                item["policy_score"] = clamp_strict_score(normalized)
+                item["policy_score"] = max(0.0, min(1.0, normalized))
         else:
-            tie_min = min(item.get("tie_break_score", 0) for item in scored)
-            tie_max = max(item.get("tie_break_score", 0) for item in scored)
+            tie_min = min(item.get("tie_break_score", 0.0) for item in scored)
+            tie_max = max(item.get("tie_break_score", 0.0) for item in scored)
             tie_spread = tie_max - tie_min
             if tie_spread > 1e-9:
                 for item in scored:
-                    normalized = (item.get("tie_break_score", 0) - tie_min) / (tie_spread + 1e-6)
+                    normalized = (item.get("tie_break_score", 0.0) - tie_min) / (tie_spread + 1e-6)
                     if normalized < 0.2:
                         jitter_seed = (
                             int(observation.get("seed", 0))
@@ -558,14 +543,14 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
                         )
                         jitter_rng = random.Random(jitter_seed)
                         normalized *= jitter_rng.uniform(0.3, 0.7)
-                    item["policy_score"] = clamp_strict_score(normalized)
+                    item["policy_score"] = max(0.0, min(1.0, normalized))
             else:
                 for item in scored:
-                    item["policy_score"] = STRICT_SCORE_MIN
+                    item["policy_score"] = 0.0
 
         # Remove hard-zero scores and normalize to probability-like values.
         for item in scored:
-            if item["policy_score"] <= 0:
+            if item["policy_score"] <= 0.0:
                 jitter_seed = (
                     int(observation.get("seed", 0))
                     + (step_number * 173)
@@ -576,7 +561,7 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
                     if item.get("specialization") == required_specialization:
                         item["policy_score"] = jitter_rng.uniform(0.08, 0.18)
                     else:
-                        item["policy_score"] = jitter_rng.uniform(0.01, 0.03)
+                        item["policy_score"] = jitter_rng.uniform(0.001, 0.01)
                 else:
                     item["policy_score"] = jitter_rng.uniform(0.05, 0.15)
 
@@ -585,7 +570,7 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
             for item in scored:
                 item["policy_score"] = item["policy_score"] / (total_score + 1e-6)
         else:
-            uniform = 1 / len(scored)
+            uniform = 1.0 / len(scored)
             for item in scored:
                 item["policy_score"] = uniform
 
@@ -605,7 +590,7 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
 
         for item in scored:
             raw_score = float(item["policy_score"])
-            normalized_score = raw_score / (1 + abs(raw_score))
+            normalized_score = raw_score / (1.0 + abs(raw_score))
             # Keep a small floor so no action is fully eliminated from exploration.
             if normalized_score < 0.01:
                 jitter_seed = (
@@ -691,7 +676,7 @@ def choose_hospital(
     else:
         policy_mode = "balanced"
 
-    safe_weight = 1
+    safe_weight = 1.0
     if policy_mode == "safe":
         safe_weight *= 0.8
         epsilon *= 0.6
@@ -729,26 +714,26 @@ def choose_hospital(
         candidates = sorted(candidates, key=lambda item: item["distance_km"])
 
     def learned_utility(item: dict) -> float:
-        base = float(item.get("policy_score", 0))
+        base = float(item.get("policy_score", 0.0))
         if not learning_profile:
             return base
         step_stats = learning_profile.get("step_stats", {}).get(str(step_number), {})
         stats = step_stats.get(item["hospital_id"], {})
         count = int(stats.get("count", 0))
         if count <= 0:
-            exploration_bonus = 0.22 * math.sqrt(max(1, math.log(attempts + 2.0)))
+            exploration_bonus = 0.22 * math.sqrt(max(1.0, math.log(attempts + 2.0)))
             return base + exploration_bonus
-        avg_reward = float(stats.get("avg_reward", 0))
-        success_rate = float(stats.get("success_rate", 0))
+        avg_reward = float(stats.get("avg_reward", 0.0))
+        success_rate = float(stats.get("success_rate", 0.0))
         rejected = int(stats.get("rejected", 0))
         rejection_rate = rejected / max(1, count)
-        exploration_bonus = 0.18 * math.sqrt(max(0, math.log(attempts + 2.0) / (count + 1)))
+        exploration_bonus = 0.18 * math.sqrt(max(0.0, math.log(attempts + 2.0) / (count + 1.0)))
         # Real-data utility: reward trend + success rate - rejection risk + exploration bonus.
         historical_weight = 0.35
         historical_weight *= 0.6
         historical_bonus = (avg_reward * historical_weight) + (success_rate * 0.30) - (rejection_rate * 0.22)
         if item["hospital_id"] in recent_failed:
-            historical_bonus = 0
+            historical_bonus = 0.0
         return base + historical_bonus + exploration_bonus
 
     def pick_improvement_candidate(route_choice_id: str | None) -> dict | None:
@@ -767,7 +752,7 @@ def choose_hospital(
         if last_status == "rejected" and previous_action and chosen.get("hospital_id") == previous_action:
             alternatives = [item for item in scored if item["hospital_id"] != previous_action]
             if alternatives:
-                rerouted = max(alternatives, key=lambda item: float(item.get("policy_score", 0)))
+                rerouted = max(alternatives, key=lambda item: float(item.get("policy_score", 0.0)))
                 return rerouted, strategy + " + immediate-retry block"
 
         # Global guardrail: when a score gap is very large, prefer best option most
@@ -786,9 +771,9 @@ def choose_hospital(
             globally_eligible = list(scored)
 
         if globally_eligible:
-            best_global = max(globally_eligible, key=lambda item: float(item.get("policy_score", 0)))
-            chosen_score = float(chosen.get("policy_score", 0))
-            best_global_score = float(best_global.get("policy_score", 0))
+            best_global = max(globally_eligible, key=lambda item: float(item.get("policy_score", 0.0)))
+            chosen_score = float(chosen.get("policy_score", 0.0))
+            best_global_score = float(best_global.get("policy_score", 0.0))
             # Cooldown hard guard: never immediately retry the just-failed hospital.
             if (last_status == "rejected" or is_rerouting_phase) and recent_hospital:
                 if chosen.get("hospital_id") == recent_hospital:
@@ -800,7 +785,7 @@ def choose_hospital(
                     if not alternatives:
                         alternatives = [item for item in scored if item["hospital_id"] != recent_hospital]
                     if alternatives:
-                        rerouted = max(alternatives, key=lambda item: float(item.get("policy_score", 0)))
+                        rerouted = max(alternatives, key=lambda item: float(item.get("policy_score", 0.0)))
                         return rerouted, strategy + " + cooldown reroute"
 
             if chosen_score < (best_global_score * 0.6):
@@ -816,9 +801,9 @@ def choose_hospital(
         guard_blocked: set[str] = set()
         for hospital_id, stats in step_stats.items():
             count = int(stats.get("count", 0))
-            success_rate = float(stats.get("success_rate", 0))
+            success_rate = float(stats.get("success_rate", 0.0))
             rejected = int(stats.get("rejected", 0))
-            if count >= 2 and success_rate <= 0 and rejected >= 2:
+            if count >= 2 and success_rate <= 0.0 and rejected >= 2:
                 guard_blocked.add(hospital_id)
 
         guarded_candidates = [item for item in candidates if item["hospital_id"] not in guard_blocked]
@@ -845,7 +830,7 @@ def choose_hospital(
                 step_number == 1
                 and baseline_candidate is not None
                 and top_candidate is not None
-                and float(baseline_candidate.get("policy_score", 0)) < float(top_candidate.get("policy_score", 0))
+                and float(baseline_candidate.get("policy_score", 0.0)) < float(top_candidate.get("policy_score", 0.0))
             ):
                 baseline_candidate = None
 
@@ -878,7 +863,7 @@ def choose_hospital(
             preferred_hospital = preferred_route[step_number - 1]
             preferred_candidate = next((item for item in candidates if item["hospital_id"] == preferred_hospital), None)
             if preferred_candidate is not None:
-                profile_score = float(learning_profile.get("best_score", 0))
+                profile_score = float(learning_profile.get("best_score", 0.0))
                 if (profile_score * safe_weight) >= 0.85 or len(candidates) == 1:
                     return enforce_score_guard(preferred_candidate, "learned best path")
 
@@ -963,13 +948,13 @@ def run_episode(
 
     if learning_profile:
         print(
-            f"Learning memory: best historical score {float(learning_profile.get('best_score', 0)):.3f} "
+            f"Learning memory: best historical score {float(learning_profile.get('best_score', 0.0)):.3f} "
             f"across {int(learning_profile.get('attempts', 0))} attempts"
         )
         if learning_profile.get("best_actions"):
             print(f"Best known route: {' -> '.join(learning_profile['best_actions'])}")
 
-    total_reward = 0
+    total_reward = 0.0
     steps = 0
     done = False
     previous_policy_hospital_id: str | None = None
@@ -990,11 +975,11 @@ def run_episode(
         if previous_policy_outcome == "REJECTED" and previous_policy_hospital_id and chosen["hospital_id"] == previous_policy_hospital_id:
             alternatives = [item for item in scored if item["hospital_id"] != previous_policy_hospital_id]
             if alternatives:
-                chosen = max(alternatives, key=lambda item: float(item.get("policy_score", 0)))
+                chosen = max(alternatives, key=lambda item: float(item.get("policy_score", 0.0)))
                 strategy = strategy + " + immediate-retry override"
 
         print_options(scored)
-        rationale = llm_rationale(llm_client, model_name or "", observation, chosen, strategy)
+        rationale = llm_rationale(cast(Optional[OpenAIClient], llm_client), model_name or "", observation, chosen, strategy)
         print(f"Decision: {chosen['hospital_id']} ({strategy})")
 
         step_result = env.step(
@@ -1016,8 +1001,6 @@ def run_episode(
         reason = str(outcome.get("reason", "No reason provided"))
         previous_policy_hospital_id = chosen["hospital_id"]
         previous_policy_outcome = status
-        reward = safe_score(reward)
-        policy_score = safe_score(chosen["policy_score"])
 
         print(f"Outcome: {status}")
         print(f"Reason: {reason}")
@@ -1033,7 +1016,6 @@ def run_episode(
                 "strategy": strategy,
                 "status": status,
                 "reward": round(reward, 4),
-                "policy_score": round(policy_score, 4),
                 "done": done,
             },
         )
@@ -1053,7 +1035,7 @@ def run_episode(
                 },
                 "action": {
                     "hospital_id": chosen["hospital_id"],
-                    "policy_score": policy_score,
+                    "policy_score": chosen["policy_score"],
                     "strategy": strategy,
                 },
                 "outcome": {
@@ -1071,7 +1053,7 @@ def run_episode(
                 "status": status,
                 "reason": reason,
                 "reward": reward,
-                "policy_score": policy_score,
+                "policy_score": chosen["policy_score"],
             }
         )
 
@@ -1079,7 +1061,7 @@ def run_episode(
 
     final_state = env.state()
     final_result = final_state.final_outcome or "FAILURE"
-    final_score = safe_score(final_state.final_score)
+    final_score = clamp_strict_score(final_state.final_score)
 
     print("\nFinal result:")
     print(f"  Result: {final_result}")
@@ -1122,7 +1104,7 @@ def update_learning_archive(archive: dict, episode_result: dict) -> None:
         key,
         {
             "attempts": 0,
-            "best_score": 0,
+            "best_score": 0.0,
             "best_actions": [],
             "best_steps": 0,
             "step_stats": {},
@@ -1138,7 +1120,7 @@ def update_learning_archive(archive: dict, episode_result: dict) -> None:
     profile["last_scenario_type"] = episode_result.get("scenario_type")
     profile["last_scenario_name"] = episode_result.get("scenario_name")
 
-    if float(episode_result["score"]) >= float(profile.get("best_score", 0)):
+    if float(episode_result["score"]) >= float(profile.get("best_score", 0.0)):
         profile["best_score"] = float(episode_result["score"])
         profile["best_actions"] = list(episode_result.get("actions", []))
         profile["best_steps"] = int(episode_result.get("steps", 0))
@@ -1160,8 +1142,8 @@ def update_learning_archive(archive: dict, episode_result: dict) -> None:
                 "accepted": 0,
                 "partial": 0,
                 "rejected": 0,
-                "total_reward": 0,
-                "avg_reward": 0,
+                "total_reward": 0.0,
+                "avg_reward": 0.0,
                 "last_status": None,
                 "last_reason": None,
             },
@@ -1287,5 +1269,3 @@ def main() -> None:
 
 if __name__ == "__main__":
     main()
-
-

openenv.yaml

@@ -1,5 +1,5 @@
 name: acde-openenv
-version: "1"
+version: "1.0"
 description: Adaptive Crisis Decision Environment
 runtime:
   transport: http
@@ -24,5 +24,5 @@ contracts:
   reward: app.models.reward.RewardModel
   info: app.models.reward.StepInfo
   state: app.models.state.EnvState
-  reward_range: [0.01, 0.99]
+  reward_range: [0.001, 0.999]
   done_type: boolean

server/app.py

@@ -1,4 +1,4 @@
-import uvicorn
+import uvicorn
 
 from app.server.app import app
 
@@ -12,4 +12,3 @@ if __name__ == "__main__":
 
 
 __all__ = ["app", "main"]
-