Upload folder using huggingface_hub

app/environment/core.py

@@ -15,6 +15,15 @@ from app.utils.calculations import compute_speed_kmh, compute_travel_time_minute
 from app.utils.randomizer import SeededRandomizer
 
 
+# Strict clamping to open interval (0, 1)
+_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))
+
+
 TASKS = {
     "acde_easy": {
         "difficulty": "easy",
@@ -1096,9 +1105,9 @@ class EmergencyEnv:
 
         total = entry.success + entry.fail
         if total == 1:
-            entry.avg = max(0.0, min(1.0, reward))
+            entry.avg = _clamp(reward)
         else:
-            normalized_reward = max(0.0, min(1.0, reward))
+            normalized_reward = _clamp(reward)
             entry.avg = ((entry.avg * (total - 1)) + normalized_reward) / total
 
         memory[hospital_id] = entry
@@ -1124,7 +1133,7 @@ class EmergencyEnv:
         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 = max(0.0, 1.0 - (rejected_steps / total_steps))
+        route_quality = _clamp(1.0 - (rejected_steps / total_steps))
         score = (0.45 * reward_component) + (0.40 * progress_component) + (0.15 * route_quality)
         return max(MIN_REWARD, min(MAX_REWARD, max(0.25, min(0.99, score))))
 

app/environment/validation.py

@@ -7,6 +7,14 @@ Outcomes are based on difficulty level, hospital capacity, patient suitability,
 from app.models.state import ArrivalOutcome, HospitalValidationDetails, HospitalState
 from app.utils.randomizer import SeededRandomizer
 
+# Strict clamping to open interval (0, 1)
+_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 HospitalValidator:
     """Performs hidden validation checks on arrival and returns outcome."""
@@ -190,7 +198,7 @@ class HospitalValidator:
         # Add difficulty-based noise
         if difficulty == "hard":
             noise = self.rng.uniform(-0.15, 0.15)
-            suitability = max(0.0, min(1.0, suitability + noise))
+            suitability = _clamp(suitability + noise)
         
         return suitability
 

app/models/observation.py

@@ -1,6 +1,6 @@
 from typing import Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 
 class HospitalObservation(BaseModel):
@@ -15,7 +15,13 @@ class ArrivalOutcomeObservation(BaseModel):
     """What happened when ambulance arrived at hospital"""
     status: Literal["accepted", "partial", "rejected"]
     reason: str
-    suitability_score: float = Field(ge=0.0, le=1.0)
+    suitability_score: float = Field(ge=0.001, le=0.999)
+    
+    @field_validator("suitability_score", mode="before")
+    @classmethod
+    def clamp_suitability(cls, v: float) -> float:
+        """Clamp to open interval (0, 1)."""
+        return max(0.001, min(0.999, v))
 
 
 class Observation(BaseModel):

app/models/state.py

@@ -1,14 +1,29 @@
 from typing import Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
+
+
+# Strict clamping to open interval (0, 1)
+_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 LearningEntry(BaseModel):
     success: int = Field(default=0, ge=0)
     fail: int = Field(default=0, ge=0)
-    avg: float = Field(default=0.0, ge=0.0, le=1.0)
+    avg: float = Field(default=0.001, ge=0.001, le=0.999)
     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:
+        """Clamp to open interval (0, 1)."""
+        return _clamp(v)
 
 
 class HospitalValidationDetails(BaseModel):
@@ -17,7 +32,13 @@ class HospitalValidationDetails(BaseModel):
     doctor_available: bool
     equipment_functional: bool
     overload_status: Literal["clear", "moderate", "severe"]
-    patient_suitability: float = Field(ge=0.0, le=1.0)  # 0=unsuitable, 1=ideal
+    patient_suitability: float = Field(ge=0.001, le=0.999)  # 0=unsuitable, 1=ideal
+    
+    @field_validator("patient_suitability", mode="before")
+    @classmethod
+    def clamp_suitability(cls, v: float) -> float:
+        """Clamp to open interval (0, 1)."""
+        return _clamp(v)
 
 
 class ArrivalOutcome(BaseModel):

app/utils/calculations.py

@@ -1,5 +1,13 @@
 from app.models.state import LearningEntry
 
+# Strict clamping to open interval (0, 1)
+_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))
+
 TRAFFIC_FACTOR = {
     "low": 1.0,
     "medium": 0.6,
@@ -18,7 +26,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 max(0.0, min(1.0, 1.0 - (distance_km / max_distance_km)))
+    return _clamp(1.0 - (distance_km / max_distance_km))
 
 
 def score_traffic(traffic: str) -> float:
@@ -26,7 +34,7 @@ def score_traffic(traffic: str) -> float:
 
 
 def score_icu(display_icu: str) -> float:
-    return 1.0 if display_icu == "available" else 0.55
+    return _clamp(1.0 if display_icu == "available" else 0.55)
 
 
 def score_memory(entry: LearningEntry | None) -> float:
@@ -38,7 +46,7 @@ def score_memory(entry: LearningEntry | None) -> float:
     success_rate = 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 max(0.0, min(1.0, raw))
+    return _clamp(raw)
 
 
 def decision_score(
@@ -53,7 +61,7 @@ def decision_score(
         + (traffic_score * 0.2)
         + (memory_score * 0.3)
     )
-    return max(0.0, min(1.0, weighted / 1.2))
+    return _clamp(weighted / 1.2)
 
 
 def compute_reward(
@@ -63,9 +71,9 @@ def compute_reward(
     specialization_match: bool,
 ) -> float:
     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)))
+    time_efficiency = _clamp(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)))
+    delay_penalty = _clamp(travel_time / max(critical_limit + travel_time, 1e-6))
 
     reward = (
         (survival_component * 0.45)
@@ -73,7 +81,7 @@ def compute_reward(
         + (specialization_component * 0.2)
         - (delay_penalty * 0.1)
     )
-    return max(0.0, min(1.0, reward))
+    return _clamp(reward)
 
 
 def compute_reward_with_breakdown(
@@ -86,19 +94,19 @@ def compute_reward_with_breakdown(
     adaptability_score: float | None = None,
 ) -> tuple[float, dict[str, float]]:
     survival_component = (
-        max(0.0, min(1.0, survival_score))
+        _clamp(survival_score)
         if survival_score is not None
         else (1.0 if survived else 0.0)
     )
-    time_efficiency = max(0.0, min(1.0, critical_limit / max(critical_limit + travel_time, 1e-6)))
+    time_efficiency = _clamp(critical_limit / max(critical_limit + travel_time, 1e-6))
     specialization_component = (
-        max(0.0, min(1.0, capability_score))
+        _clamp(capability_score)
         if capability_score is not None
         else (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)))
+    delay_penalty = _clamp(travel_time / max(critical_limit + travel_time, 1e-6))
     adapt_component = (
-        max(0.0, min(1.0, adaptability_score))
+        _clamp(adaptability_score)
         if adaptability_score is not None
         else 0.5
     )
@@ -110,7 +118,7 @@ def compute_reward_with_breakdown(
         + (adapt_component * 0.2)
         - (delay_penalty * 0.12)
     )
-    reward = max(0.0, min(1.0, reward))
+    reward = _clamp(reward)
     return reward, {
         "survival_component": survival_component,
         "time_efficiency_component": time_efficiency,

data/learning_archive.json

@@ -8723,6 +8723,197 @@
       "best_scenario_name": "Mass Cardiac Event (Overload)",
       "best_difficulty": "hard",
       "best_required_specialization": "cardiac"
+    },
+    "917229607|acde_easy": {
+      "attempts": 1,
+      "best_score": 0.9038000000000002,
+      "best_actions": [
+        "H1"
+      ],
+      "best_steps": 1,
+      "step_stats": {
+        "1": {
+          "H1": {
+            "count": 1,
+            "success": 1,
+            "accepted": 1,
+            "partial": 0,
+            "rejected": 0,
+            "total_reward": 0.8870000000000001,
+            "avg_reward": 0.8870000000000001,
+            "last_status": "ACCEPTED",
+            "last_reason": "Patient stabilized after delayed admission",
+            "success_rate": 1.0
+          }
+        }
+      },
+      "last_score": 0.9038000000000002,
+      "last_success": true,
+      "last_run_at": "2026-04-09T09:44:05.035745+00:00",
+      "last_actions": [
+        "H1"
+      ],
+      "last_required_specialization": "general",
+      "last_scenario_type": "fire",
+      "last_scenario_name": "Apartment Fire (Smoke Inhalation)",
+      "best_success": true,
+      "best_scenario_name": "Apartment Fire (Smoke Inhalation)",
+      "best_difficulty": "easy",
+      "best_required_specialization": "general"
+    },
+    "917229608|acde_medium": {
+      "attempts": 1,
+      "best_score": 0.483,
+      "best_actions": [
+        "H5",
+        "H2",
+        "H5"
+      ],
+      "best_steps": 3,
+      "step_stats": {
+        "1": {
+          "H5": {
+            "count": 1,
+            "success": 0,
+            "accepted": 0,
+            "partial": 1,
+            "rejected": 0,
+            "total_reward": 0.499,
+            "avg_reward": 0.499,
+            "last_status": "PARTIAL",
+            "last_reason": "Admitted with delays: patient worsened during transfer",
+            "success_rate": 0.0
+          }
+        },
+        "2": {
+          "H2": {
+            "count": 1,
+            "success": 0,
+            "accepted": 0,
+            "partial": 0,
+            "rejected": 1,
+            "total_reward": 0.039,
+            "avg_reward": 0.039,
+            "last_status": "REJECTED",
+            "last_reason": "Hospital cannot admit: Hospital overloaded",
+            "success_rate": 0.0
+          }
+        },
+        "3": {
+          "H5": {
+            "count": 1,
+            "success": 1,
+            "accepted": 1,
+            "partial": 0,
+            "rejected": 0,
+            "total_reward": 0.5336,
+            "avg_reward": 0.5336,
+            "last_status": "ACCEPTED",
+            "last_reason": "Patient stabilized after critical delay",
+            "success_rate": 1.0
+          }
+        }
+      },
+      "last_score": 0.483,
+      "last_success": true,
+      "last_run_at": "2026-04-09T09:44:06.199323+00:00",
+      "last_actions": [
+        "H5",
+        "H2",
+        "H5"
+      ],
+      "last_required_specialization": "cardiac",
+      "last_scenario_type": "medical",
+      "last_scenario_name": "Heart Attack (Unstable)",
+      "best_success": true,
+      "best_scenario_name": "Heart Attack (Unstable)",
+      "best_difficulty": "medium",
+      "best_required_specialization": "cardiac"
+    },
+    "917229609|acde_hard": {
+      "attempts": 1,
+      "best_score": 0.1684125,
+      "best_actions": [
+        "H2",
+        "H6",
+        "H2",
+        "H2"
+      ],
+      "best_steps": 4,
+      "step_stats": {
+        "1": {
+          "H2": {
+            "count": 1,
+            "success": 0,
+            "accepted": 0,
+            "partial": 0,
+            "rejected": 1,
+            "total_reward": 0.139,
+            "avg_reward": 0.139,
+            "last_status": "REJECTED",
+            "last_reason": "Hospital cannot admit: No specialist available, Hospital overloaded",
+            "success_rate": 0.0
+          }
+        },
+        "2": {
+          "H6": {
+            "count": 1,
+            "success": 0,
+            "accepted": 0,
+            "partial": 0,
+            "rejected": 1,
+            "total_reward": 0.001,
+            "avg_reward": 0.001,
+            "last_status": "REJECTED",
+            "last_reason": "Hospital cannot admit: No specialist available",
+            "success_rate": 0.0
+          }
+        },
+        "3": {
+          "H2": {
+            "count": 1,
+            "success": 0,
+            "accepted": 0,
+            "partial": 1,
+            "rejected": 0,
+            "total_reward": 0.148,
+            "avg_reward": 0.148,
+            "last_status": "PARTIAL",
+            "last_reason": "Admitted with significant risk: ICU unavailable",
+            "success_rate": 0.0
+          }
+        },
+        "4": {
+          "H2": {
+            "count": 1,
+            "success": 0,
+            "accepted": 0,
+            "partial": 0,
+            "rejected": 1,
+            "total_reward": 0.001,
+            "avg_reward": 0.001,
+            "last_status": "REJECTED",
+            "last_reason": "Hospital cannot admit: Hospital overloaded",
+            "success_rate": 0.0
+          }
+        }
+      },
+      "last_score": 0.1684125,
+      "last_success": false,
+      "last_run_at": "2026-04-09T09:44:07.652831+00:00",
+      "last_actions": [
+        "H2",
+        "H6",
+        "H2",
+        "H2"
+      ],
+      "last_required_specialization": "trauma",
+      "last_scenario_type": "accident",
+      "last_scenario_name": "Bridge Crash (Infrastructure Blocked)",
+      "best_success": false,
+      "best_scenario_name": "Bridge Crash (Infrastructure Blocked)",
+      "best_difficulty": "hard",
+      "best_required_specialization": "trauma"
     }
   },
   "episodes": [
@@ -10910,6 +11101,50 @@
         "H2"
       ],
       "timestamp": "2026-04-09T08:48:36.666940+00:00"
+    },
+    {
+      "seed": 917229607,
+      "task_id": "acde_easy",
+      "difficulty": "easy",
+      "required_specialization": "general",
+      "scenario_name": "Apartment Fire (Smoke Inhalation)",
+      "score": 0.9038000000000002,
+      "success": true,
+      "actions": [
+        "H1"
+      ],
+      "timestamp": "2026-04-09T09:44:05.035745+00:00"
+    },
+    {
+      "seed": 917229608,
+      "task_id": "acde_medium",
+      "difficulty": "medium",
+      "required_specialization": "cardiac",
+      "scenario_name": "Heart Attack (Unstable)",
+      "score": 0.483,
+      "success": true,
+      "actions": [
+        "H5",
+        "H2",
+        "H5"
+      ],
+      "timestamp": "2026-04-09T09:44:06.199323+00:00"
+    },
+    {
+      "seed": 917229609,
+      "task_id": "acde_hard",
+      "difficulty": "hard",
+      "required_specialization": "trauma",
+      "scenario_name": "Bridge Crash (Infrastructure Blocked)",
+      "score": 0.1684125,
+      "success": false,
+      "actions": [
+        "H2",
+        "H6",
+        "H2",
+        "H2"
+      ],
+      "timestamp": "2026-04-09T09:44:07.652831+00:00"
     }
   ]
 }

data/learning_memory.json

@@ -1,30 +1,30 @@
 {
   "H2": {
-    "success": 111,
-    "fail": 214,
-    "avg": 0.3359261538461545,
-    "accepted": 111,
-    "rejected": 214
+    "success": 112,
+    "fail": 216,
+    "avg": 0.3334268292682933,
+    "accepted": 112,
+    "rejected": 216
   },
   "H6": {
     "success": 50,
-    "fail": 145,
-    "avg": 0.291038461538462,
+    "fail": 146,
+    "avg": 0.28955867346938824,
     "accepted": 50,
-    "rejected": 145
+    "rejected": 146
   },
   "H5": {
-    "success": 116,
-    "fail": 179,
-    "avg": 0.38248847457627094,
-    "accepted": 116,
-    "rejected": 179
+    "success": 118,
+    "fail": 180,
+    "avg": 0.3825694630872481,
+    "accepted": 118,
+    "rejected": 180
   },
   "H1": {
-    "success": 111,
+    "success": 112,
     "fail": 117,
-    "avg": 0.401454385964912,
-    "accepted": 111,
+    "avg": 0.4035746724890827,
+    "accepted": 112,
     "rejected": 117
   },
   "H3": {

data/trajectory_history.jsonl

@@ -383,3 +383,11 @@
 {"seed": 468098217, "task": "acde_hard", "difficulty": "hard", "step": 2, "state": {"patient_condition": "critical", "remaining_time_minutes": 12.0, "failed_hospitals": ["H2"], "visited_hospitals": ["H2"], "ambulance_status": "rerouting"}, "action": {"hospital_id": "H3", "policy_score": 0.29411764705882354, "strategy": "risk-aware policy"}, "outcome": {"status": "REJECTED", "reason": "Hidden mismatch at arrival (wrong risky guess). Rerouting required."}, "reward": 0.001}
 {"seed": 468098217, "task": "acde_hard", "difficulty": "hard", "step": 3, "state": {"patient_condition": "critical", "remaining_time_minutes": 12.0, "failed_hospitals": ["H2", "H3"], "visited_hospitals": ["H2", "H3"], "ambulance_status": "rerouting"}, "action": {"hospital_id": "H5", "policy_score": 0.039999999999999994, "strategy": "risk-aware policy"}, "outcome": {"status": "REJECTED", "reason": "Hidden mismatch at arrival (wrong risky guess). Rerouting required."}, "reward": 0.001}
 {"seed": 468098217, "task": "acde_hard", "difficulty": "hard", "step": 4, "state": {"patient_condition": "critical", "remaining_time_minutes": 12.0, "failed_hospitals": ["H2", "H3", "H1"], "visited_hospitals": ["H2", "H3", "H1"], "ambulance_status": "rerouting"}, "action": {"hospital_id": "H2", "policy_score": 0.29411764705882354, "strategy": "risk-aware policy + immediate-retry override"}, "outcome": {"status": "REJECTED", "reason": "Hospital cannot admit: ICU unavailable, No specialist available"}, "reward": 0.001}
+{"seed": 917229607, "task": "acde_easy", "difficulty": "easy", "step": 1, "state": {"patient_condition": "serious", "remaining_time_minutes": 18.0, "failed_hospitals": [], "visited_hospitals": [], "ambulance_status": "en_route"}, "action": {"hospital_id": "H1", "policy_score": 0.330194953786115, "strategy": "safe policy"}, "outcome": {"status": "ACCEPTED", "reason": "Patient stabilized after delayed admission"}, "reward": 0.8870000000000001}
+{"seed": 917229608, "task": "acde_medium", "difficulty": "medium", "step": 1, "state": {"patient_condition": "critical", "remaining_time_minutes": 14.0, "failed_hospitals": [], "visited_hospitals": [], "ambulance_status": "en_route"}, "action": {"hospital_id": "H5", "policy_score": 0.49333881522073353, "strategy": "safe policy + critical triage"}, "outcome": {"status": "PARTIAL", "reason": "Admitted with delays: patient worsened during transfer"}, "reward": 0.499}
+{"seed": 917229608, "task": "acde_medium", "difficulty": "medium", "step": 2, "state": {"patient_condition": "critical", "remaining_time_minutes": 14.0, "failed_hospitals": [], "visited_hospitals": ["H5"], "ambulance_status": "in_transit"}, "action": {"hospital_id": "H2", "policy_score": 0.39089664384926215, "strategy": "balanced policy + critical triage"}, "outcome": {"status": "REJECTED", "reason": "Hospital cannot admit: Hospital overloaded"}, "reward": 0.039}
+{"seed": 917229608, "task": "acde_medium", "difficulty": "medium", "step": 3, "state": {"patient_condition": "critical", "remaining_time_minutes": 14.0, "failed_hospitals": ["H2"], "visited_hospitals": ["H5", "H2"], "ambulance_status": "rerouting"}, "action": {"hospital_id": "H5", "policy_score": 0.47656977550308066, "strategy": "risk-aware policy + guided-exploration + anti-stupidity guard"}, "outcome": {"status": "ACCEPTED", "reason": "Patient stabilized after critical delay"}, "reward": 0.5336}
+{"seed": 917229609, "task": "acde_hard", "difficulty": "hard", "step": 1, "state": {"patient_condition": "critical", "remaining_time_minutes": 13.0, "failed_hospitals": [], "visited_hospitals": [], "ambulance_status": "en_route"}, "action": {"hospital_id": "H2", "policy_score": 0.49956106431243036, "strategy": "safe policy"}, "outcome": {"status": "REJECTED", "reason": "Hospital cannot admit: No specialist available, Hospital overloaded"}, "reward": 0.139}
+{"seed": 917229609, "task": "acde_hard", "difficulty": "hard", "step": 2, "state": {"patient_condition": "critical", "remaining_time_minutes": 13.0, "failed_hospitals": ["H5"], "visited_hospitals": ["H5"], "ambulance_status": "rerouting"}, "action": {"hospital_id": "H6", "policy_score": 0.025524969981599324, "strategy": "risk-aware policy + immediate-retry override"}, "outcome": {"status": "REJECTED", "reason": "Hospital cannot admit: No specialist available"}, "reward": 0.001}
+{"seed": 917229609, "task": "acde_hard", "difficulty": "hard", "step": 3, "state": {"patient_condition": "critical", "remaining_time_minutes": 13.0, "failed_hospitals": ["H5", "H6"], "visited_hospitals": ["H5", "H6"], "ambulance_status": "rerouting"}, "action": {"hospital_id": "H2", "policy_score": 0.4, "strategy": "risk-aware policy"}, "outcome": {"status": "PARTIAL", "reason": "Admitted with significant risk: ICU unavailable"}, "reward": 0.148}
+{"seed": 917229609, "task": "acde_hard", "difficulty": "hard", "step": 4, "state": {"patient_condition": "critical", "remaining_time_minutes": 13.0, "failed_hospitals": ["H5", "H6"], "visited_hospitals": ["H5", "H6", "H2"], "ambulance_status": "in_transit"}, "action": {"hospital_id": "H2", "policy_score": 0.4, "strategy": "balanced policy + critical triage + anti-stupidity guard"}, "outcome": {"status": "REJECTED", "reason": "Hospital cannot admit: Hospital overloaded"}, "reward": 0.001}

inference.py

@@ -42,6 +42,14 @@ DEFAULT_API_BASE_URL = "https://api-inference.huggingface.co/v1"
 DEFAULT_MODEL_NAME = "Qwen/Qwen2.5-72B-Instruct"
 REQUIRED_ENV_VARS = ("HF_TOKEN",)
 
+# Strict clamping to open interval (0, 1)
+_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))
+
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="EmergencyEnv agent runner")
@@ -315,7 +323,7 @@ def memory_score_for_hospital(
     if recent_failed:
         value -= 0.3
 
-    return max(0.0, min(1.0, value))
+    return _clamp(value)
 
 
 def score_hospitals(observation: dict, learning_profile: dict | None = None) -> list[dict]:
@@ -348,8 +356,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 = max(0.0, min(1.0, 1.0 - hospital["distance_km"] / 20.0))
-        icu_score = 1.0 if hospital["icu"] == "available" else 0.55
+        distance_score = _clamp(1.0 - hospital["distance_km"] / 20.0)
+        icu_score = _clamp(1.0 if hospital["icu"] == "available" else 0.55)
         mem_score = memory_score_for_hospital(
             hospital["hospital_id"],
             memory_snapshot,
@@ -454,13 +462,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 = max(0.0, min(1.0, base_current_score))
+        confidence_score = _clamp(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 = 0.0
+            effective_memory_score = _FLOOR
         if confidence_score < 0.2:
-            effective_memory_score = 0.0
+            effective_memory_score = _FLOOR
 
         score = (current_score_weight * base_current_score) + (memory_weight * effective_memory_score)
 
@@ -473,7 +481,7 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
                 "specialization": hospital["specialization"],
                 "travel_time": travel_time,
                 "memory_score": mem_score,
-                "policy_score": max(0.0, min(1.0, score)),
+                "policy_score": _clamp(score),
                 "specialization_match": spec_match,
                 "tie_break_score": (
                     (distance_score * 0.35)
@@ -500,7 +508,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"] = max(0.0, min(1.0, normalized))
+                item["policy_score"] = _clamp(normalized)
         elif max_score > 0:
             for item in scored:
                 normalized = item["policy_score"] / max_score
@@ -512,7 +520,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"] = max(0.0, min(1.0, normalized))
+                item["policy_score"] = _clamp(normalized)
         else:
             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)
@@ -528,14 +536,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"] = max(0.0, min(1.0, normalized))
+                    item["policy_score"] = _clamp(normalized)
             else:
                 for item in scored:
-                    item["policy_score"] = 0.0
+                    item["policy_score"] = _FLOOR
 
         # Remove hard-zero scores and normalize to probability-like values.
         for item in scored:
-            if item["policy_score"] <= 0.0:
+            if item["policy_score"] <= _FLOOR:
                 jitter_seed = (
                     int(observation.get("seed", 0))
                     + (step_number * 173)
@@ -544,11 +552,11 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
                 jitter_rng = random.Random(jitter_seed)
                 if critical_patient and required_specialization != "general":
                     if item.get("specialization") == required_specialization:
-                        item["policy_score"] = jitter_rng.uniform(0.08, 0.18)
+                        item["policy_score"] = _clamp(jitter_rng.uniform(0.08, 0.18))
                     else:
-                        item["policy_score"] = jitter_rng.uniform(0.001, 0.01)
+                        item["policy_score"] = _clamp(jitter_rng.uniform(0.001, 0.01))
                 else:
-                    item["policy_score"] = jitter_rng.uniform(0.05, 0.15)
+                    item["policy_score"] = _clamp(jitter_rng.uniform(0.05, 0.15))
 
         total_score = sum(item["policy_score"] for item in scored)
         if total_score > 0:
@@ -584,8 +592,8 @@ def score_hospitals(observation: dict, learning_profile: dict | None = None) ->
                     + sum(ord(ch) for ch in item["hospital_id"])
                 )
                 jitter_rng = random.Random(jitter_seed)
-                normalized_score = jitter_rng.uniform(0.01, 0.03)
-            item["policy_score"] = normalized_score
+                normalized_score = _clamp(jitter_rng.uniform(0.01, 0.03))
+            item["policy_score"] = _clamp(normalized_score)
 
         scored.sort(key=lambda item: item["policy_score"], reverse=True)