fixed task 1, 2, 3

grader.py

@@ -60,23 +60,36 @@ class Grade:
 
         Weights deliberately penalise cost heavily so that brute-force
         SCALE_UP spam cannot achieve a high composite even with perfect uptime.
-        A purely reactive agent that always SCALE_UPs is bounded by:
-            0.4 * 1.0 + 0.2 * 1.0 + 0.4 * ~0.0  ≈ 0.60 (worst-case)
-        An intelligent agent that right-sizes capacity can reach 0.9+.
+        
+        Hardening:
+        - Task 3 coupling: Cost only rewards if Uptime is >= 50%. Stops 'Cheap-but-Dead'.
+        - Invalid Action Penalty: -0.05 per forbidden command (SHED_LOAD on critical).
         """
-        return (
-            0.4 * self.scores["uptime"] +
-            0.2 * self.scores["stability"] +
-            0.4 * self.scores["cost"]
-        )
+        uptime = self.scores["uptime"]
+        stability = self.scores["stability"]
+        cost = self.scores["cost"]
+        invalid_penalty = self.scores.get("invalid_actions", 0) * 0.05
+
+        if self.task_id == "task-3":
+            # Coupling: If uptime < 0.5, the cost benefit is zeroed out.
+            # Mirroring real-world priority: Budget doesn't matter if the site is down.
+            cost_weight = 1.0 if uptime >= 0.5 else 0.0
+            score = (0.4 * uptime + 0.2 * stability + 0.4 * (cost * cost_weight))
+        else:
+            score = (0.4 * uptime + 0.2 * stability + 0.4 * cost)
+            
+        return max(0.0, score - invalid_penalty)
 
     def summary(self) -> str:
         s = self.scores
-        return (
+        summary = (
             f"[{self.task_id}] composite={self.composite:.3f} | "
             f"uptime={s['uptime']:.3f} | cost={s['cost']:.3f} | "
             f"stability={s['stability']:.3f} | SLA violations={int(s['violations'])}/101"
         )
+        if s.get("invalid_actions", 0) > 0:
+            summary += f" | INVALID ACTIONS={int(s['invalid_actions'])}"
+        return summary
 
 
 class EpisodeGrader:
@@ -135,11 +148,15 @@ class EpisodeGrader:
             ratio = avg_energy / TARGET_ENERGY
             stability_score = 1.0 / (1.0 + (ratio ** STABILITY_CURVE_POWER))
 
+        # ── 4. Invalid Action tracking ──────────────────────────────────────
+        total_invalid = self._records[-1].get("invalid_action_count", 0)
+
         return Grade(self.task_id, {
             "uptime": uptime_score,
             "cost": cost_score,
             "stability": stability_score,
-            "violations": total_violations
+            "violations": total_violations,
+            "invalid_actions": total_invalid
         })
 
 

models.py

@@ -124,6 +124,11 @@ class ClusterObservation(BaseModel):
         description="Cumulative count of SLA violations this episode.",
     )
 
+    invalid_action_count: int = Field(
+        default=0,
+        description="Number of forbidden actions (e.g. SHED_LOAD on critical nodes).",
+    )
+
     nodes: list[NodeObservation]
 
     # Episode interaction fields (handled by framework)

server/AntiAtropos_environment.py

@@ -206,6 +206,7 @@ class AntiAtroposEnvironment(Environment):
             step=self._state.step_count,
             max_steps=MAX_STEPS,
             sla_violations=self._sla_violations,
+            invalid_action_count=self._sim.invalid_action_count,
             done=False,
             reward=0.0,
         )

simulator.py

@@ -55,6 +55,10 @@ T3_SURGE_BASE_END:     int   = 40   # Nominal end of surge within cycle
 T3_SURGE_JITTER:       int   = 10   # ±jitter applied to start/end each episode
 T3_SURGE_MAGNITUDE:    float = 70.0 # Extra req/tick added to node-1 and node-2
 
+# Hardening: Critical infrastructure that CANNOT be shed
+# In Task 3, these receive the surge. Forcing the agent to SCALE.
+CRITICAL_NODES: list[str] = ["node-0", "node-1", "node-2"]
+
 
 class NodeStatus(str, Enum):
     HEALTHY  = "HEALTHY"
@@ -132,6 +136,7 @@ class ClusterSimulator:
         # Per-node reroute weights for REROUTE_TRAFFIC (node_id → fraction)
         self._reroute_weights: dict[str, float] = {}
         self._nodes: list[NodeState] = []
+        self.invalid_action_count: int = 0
         self._randomize_domain()
         self._reset_nodes()
 
@@ -166,6 +171,7 @@ class ClusterSimulator:
         self._tick_count = 0
         self._failed_node_id = None
         self._reroute_weights = {}
+        self.invalid_action_count = 0
         self._randomize_domain()
         self._reset_nodes()
 
@@ -217,6 +223,12 @@ class ClusterSimulator:
             self._reroute_weights[node_id] = frac
 
         elif at == "SHED_LOAD":
+            # Rule: Cannot shed critical nodes (database/control plane).
+            # This forces the agent to handle Task-3 surge via Scaling/Rerouting.
+            if node_id in CRITICAL_NODES:
+                self.invalid_action_count += 1
+                return 
+
             frac = min(1.0, param)
             target.shed_fraction = frac
             # Note: physically applied in _update_queues() to incoming traffic