Fix 8 issues spotted in code review: Dockerfile path, task descriptions, duplicate function, fallback score consistency, twin constants comment, has_data_lag docs

README.md

@@ -147,11 +147,11 @@ new_infection = current + (spread_rate − natural_recovery − intervention) +
 | --- | --- | --- | --- | --- | --- |
 | **easy** | 2 | 10 | 10 | None | Single outbreak; D1 starts infected, D0 is clean |
 | **medium** | 4 | 15 | 8 | None | Two simultaneous outbreaks; forced triage between competing threats |
-| **hard** | 6 | 15 | 7 | **3 days** | Six growing outbreaks; invisible acceleration; scarce resources |
+| **hard** | 6 | 15 | 7 | **3 days** | Six seeded infections (only D2 and D4 above safe threshold); 3-day data lag; scarce resources |
 
 **Easy** — D1 starts at 0.50 infection, D0 is clean. The agent must observe and target the correct district. A fixed-target agent ignoring observations scores ~43% and breaches hospitals 60% of the time.
 
-**Medium** — D0 and D2 start in the danger zone; D1 and D3 grow into crisis within 4–6 steps. With 8 resources across 4 districts over 15 steps, genuine triage is required.
+**Medium** — D0 starts above the infection threshold (0.42); D2 is in the warning zone (0.38, below the 0.40 threshold). D1 and D3 start low but grow into crisis within 4–6 steps via spillover. With 8 resources across 4 districts over 15 steps, genuine triage is required.
 
 **Hard** — 3-day information lag means the agent sees infection rates from 3 days ago. The `growth_rate_hint` provides a noisy signal to estimate current state. Structural uncertainty — not testable around.
 
@@ -179,7 +179,7 @@ Fully deterministic — no randomness, no LLM calls. Identical trajectories alwa
 | --- | --- | --- |
 | **Hospital score** | 45% | Average capacity preserved; ×0.6 multiplier if any district collapsed |
 | **Containment score** | 30% | Fraction of district-days below infection threshold (first 2 steps excluded) |
-| **Efficiency score** | 15% | Fraction of resource actions targeting highest-infected district (uses pre-action state) |
+| **Efficiency score** | 15% | Fraction of resource actions targeting highest-infected district (grader uses pre-action state to avoid penalising successful treatments) |
 | **Speed score** | 10% | `1 − (steps / max_steps)` if episode ends early; else 0 |
 
 Hospital is weighted highest because system capacity preservation is the primary operational constraint in real outbreak response — a functioning healthcare system is the prerequisite for everything else.
@@ -309,7 +309,7 @@ python baseline/run.py
 ### Docker
 
 ```bash
-docker build -f server/Dockerfile -t cascade-containment .
+docker build -t cascade-containment .
 docker run -p 7860:7860 cascade-containment
 ```
 

baseline/evaluator.py

@@ -5,7 +5,7 @@ from openai import OpenAI
 
 from client import CascadeContainmentEnv
 from models import ContainmentAction, CityObservation
-from baseline.policy import get_client, build_prompt, call_llm, parse_action
+from baseline.policy import get_client, build_prompt, call_llm, parse_action, build_prompt_with_memory
 from core.trajectory import EpisodicMemory
 from core.reward import normalise_score
 from core.policy_update import compute_advantage, update_memory
@@ -18,15 +18,6 @@ N_ROLLOUTS = {
 }
 
 
-def build_prompt_with_memory(obs: CityObservation, memory: EpisodicMemory) -> str:
-    base         = build_prompt(obs)
-    memory_block = memory.retrieve(obs)
-    if not memory_block:
-        return base
-    injection = "\n" + memory_block + "\nApply these lessons to your current decision.\n"
-    return base.replace("Your response:", injection + "Your response:")
-
-
 def run_rollout(
     env: Any, task_name: str, client: OpenAI,
     memory: EpisodicMemory, verbose: bool = True,

baseline/policy.py

@@ -13,6 +13,11 @@ def get_client() -> OpenAI:
 
 def build_prompt(obs: CityObservation) -> str:
     num_districts = len(obs.districts)
+    # Infers data lag from district count because CityObservation does not expose
+    # data_lag_days directly. This works because hard (6 districts) is currently the
+    # only task with a data lag. If a new task is added with 6 districts and no lag,
+    # or a lag task with fewer districts, this will silently misbehave.
+    # Fix: expose data_lag_days in CityObservation and read it directly.
     has_data_lag  = num_districts == 6
 
     sorted_districts = sorted(
@@ -169,3 +174,17 @@ def get_action(obs: CityObservation, client: OpenAI) -> ContainmentAction:
     prompt   = build_prompt(obs)
     response = call_llm(prompt, client)
     return parse_action(response, len(obs.districts))
+
+
+def build_prompt_with_memory(obs: CityObservation, memory) -> str:
+    """
+    Builds the LLM prompt augmented with relevant past decisions from episodic memory.
+    Injects memory block just before the 'Your response:' line so the model sees
+    prior high-reward decisions as concrete examples before making its choice.
+    """
+    base         = build_prompt(obs)
+    memory_block = memory.retrieve(obs)
+    if not memory_block:
+        return base
+    injection = "\n" + memory_block + "\nApply these lessons to your current decision.\n"
+    return base.replace("Your response:", injection + "Your response:")

inference.py

@@ -10,9 +10,10 @@ import requests as http_requests
 
 from client import CascadeContainmentEnv
 from models import ContainmentAction
-from baseline.policy import get_client, build_prompt, call_llm, parse_action
+from baseline.policy import get_client, build_prompt, call_llm, parse_action, build_prompt_with_memory
 from core.trajectory import EpisodicMemory
 from core.policy_update import compute_advantage, update_memory
+from core.reward import normalise_score
 
 API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
 MODEL_NAME   = os.getenv("MODEL_NAME",   "meta-llama/Llama-3.1-8B-Instruct")
@@ -48,15 +49,6 @@ def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> No
     )
 
 
-def build_prompt_with_memory(obs, memory: EpisodicMemory) -> str:
-    base         = build_prompt(obs)
-    memory_block = memory.retrieve(obs)
-    if not memory_block:
-        return base
-    injection = "\n" + memory_block + "\nApply these lessons to your current decision.\n"
-    return base.replace("Your response:", injection + "Your response:")
-
-
 def run_rollout(
     env,
     task_name:   str,
@@ -108,7 +100,8 @@ def run_rollout(
             if grade_resp.status_code == 200:
                 score = grade_resp.json().get("final_score", 0.0)
         except Exception:
-            score = max(0.0, min(1.0, (total_reward + 5) / 15))
+            num_districts = {"easy": 2, "medium": 4, "hard": 6}.get(task_name, 2)
+            score = normalise_score(total_reward, step, num_districts)
 
         success = score >= 0.40
 

server/constants.py

@@ -8,7 +8,10 @@ TASK_CONFIG = {
 }
 
 INFECTION_THRESHOLD   = 0.40   # above this → district is in the danger zone
-SAFE_THRESHOLD        = 0.20   # below this → district is considered contained
+SAFE_THRESHOLD        = 0.20   # below this → district is considered contained (grader + terminal check)
+# LOW_THRESHOLD and SAFE_THRESHOLD are intentionally separate even though both equal 0.20.
+# SAFE_THRESHOLD is a containment concept; LOW_THRESHOLD is a restriction-penalty concept.
+# Keeping them separate means they can diverge independently if the design changes.
 LOW_THRESHOLD         = 0.20   # restricting below this threshold earns a penalty
 # real ICU overflow and triage failure kick in well before zero capacity
 HOSPITAL_BREACH_POINT = 0.10