Fix: Easy task with overscaled instances

env/core.py

@@ -42,11 +42,11 @@ TASKS = {
         difficulty="easy",
         description="Optimize this 3-server cluster. Start by analyzing load patterns, then iteratively adjust each server. Final reward requires ALL servers properly sized.",
         initial_resources=[
-            {"id": "srv-1", "type": "m5.large", "cpu_usage": 20.0, "mem_usage": 15.0, "monthly_cost": 70.0},
-            {"id": "srv-2", "type": "m5.large", "cpu_usage": 18.0, "mem_usage": 12.0, "monthly_cost": 70.0},
-            {"id": "srv-3", "type": "m5.large", "cpu_usage": 22.0, "mem_usage": 16.0, "monthly_cost": 70.0},
+            {"id": "srv-1", "type": "m5.xlarge", "cpu_usage": 10.0, "mem_usage": 8.0, "monthly_cost": 140.0},
+            {"id": "srv-2", "type": "m5.xlarge", "cpu_usage": 8.0, "mem_usage": 6.0, "monthly_cost": 140.0},
+            {"id": "srv-3", "type": "m5.xlarge", "cpu_usage": 12.0, "mem_usage": 9.0, "monthly_cost": 140.0},
         ],
-        sla={"max_latency_ms": 120.0, "max_budget": 80.0, "min_uptime_pct": 99.0},
+        sla={"max_latency_ms": 120.0, "max_budget": 100.0, "min_uptime_pct": 99.0},
         load=30.0
     ),
     "medium": TaskConfig(
@@ -164,7 +164,7 @@ class CloudOpsEnvironment:
             self._ep.resources
         )
         
-        if utilization > 1.3:
+        if utilization > 1.5:
             self._ep.crashed = True
             obs = self._build_observation("SYSTEM CRASH: Resource exhaustion!")
             reward = RewModel(value=0.0, reason="System crashed due to resource exhaustion")
@@ -212,79 +212,31 @@ class CloudOpsEnvironment:
     
     def _calculate_metrics(self, load: float, resources: list) -> Tuple[float, float, float]:
         total_cap = sum(INSTANCE_DATA[r.type]["capacity"] for r in resources)
-        utilization = load / (total_cap + 1e-6)
+        avg_utilization = load / total_cap if total_cap > 0 else 0
         
-        latency = 50 * (1 + math.exp(utilization * 2 - 2))
-        error_rate = 0.0 if utilization < 0.9 else (utilization - 0.9) * 2.0
+        utilization = min(avg_utilization, 1.5)
         
-        return latency, error_rate, utilization
-    
-    def _calculate_iterative_reward(
-        self, 
-        latency: float, 
-        error_rate: float,
-        new_cost: float,
-        prev_cost: float,
-        prev_latency: float
-    ) -> RewModel:
-        task = self._ep.task_config
-        budget = task.sla["max_budget"]
-        max_latency = task.sla["max_latency_ms"]
-        
-        cost_improvement = (prev_cost - new_cost) / (prev_cost + 1e-6)
-        latency_improvement = (prev_latency - latency) / (prev_latency + 1e-6)
-        
-        change_bonus = min(self._ep.changes_made * 0.06, 0.3)
-        
-        cost_ratio = new_cost / budget
-        cost_reward = 0.3 * (1.0 / (1.0 + max(0, cost_ratio - 1)))
-        
-        lat_ratio = latency / max_latency
-        perf_reward = 0.3 * (1.0 / (1.0 + max(0, lat_ratio - 1)))
-        
-        improvement_bonus = 0.0
-        if cost_improvement > 0:
-            improvement_bonus += min(cost_improvement * 0.15, 0.1)
-        if latency_improvement > 0:
-            improvement_bonus += min(latency_improvement * 0.15, 0.1)
+        latency = 30 + 70 * (avg_utilization ** 2)
+        error_rate = max(0, (avg_utilization - 0.85) * 2)
         
-        base_reward = cost_reward + perf_reward
-        total_reward = min(1.0, base_reward + change_bonus + improvement_bonus)
-        
-        if error_rate > 0.1:
-            total_reward *= (1.0 - error_rate)
-        
-        exploration_bonus = min(self._ep.steps * 0.03, 0.15)
-        if self._ep.last_action_success:
-            total_reward = min(1.0, total_reward + exploration_bonus)
-        
-        initial_latency = self._ep.initial_latency
-        initial_cost = self._ep.initial_cost
-        cost_change = ((new_cost - initial_cost) / initial_cost) * 100 if initial_cost > 0 else 0
-        lat_change = ((latency - initial_latency) / initial_latency) * 100 if initial_latency > 0 else 0
-        
-        return RewModel(
-            value=min(1.0, max(0.0, total_reward)),
-            reason=f"Changes: {self._ep.changes_made}, Cost: ${new_cost:.1f}, Latency: {latency:.1f}ms",
-            cost_change_pct=cost_change,
-            latency_change_pct=lat_change,
-        )
+        return latency, error_rate, avg_utilization
     
     def _build_observation(self, message: str) -> ObsModel:
         if self._ep is None:
             return self._error_obs()
             
-        latency, error_rate, _ = self._calculate_metrics(
+        latency, error_rate, utilization = self._calculate_metrics(
             self._ep.current_load,
             self._ep.resources
         )
         
-        total_capacity = sum(INSTANCE_DATA[r.type]["capacity"] for r in self._ep.resources)
+        total_cap = sum(INSTANCE_DATA[r.type]["capacity"] for r in self._ep.resources)
         
         for r in self._ep.resources:
             cap = INSTANCE_DATA[r.type]["capacity"]
-            r.cpu_usage = min(100.0, self._ep.current_load / total_capacity / cap * 100)
-            r.mem_usage = min(100.0, r.cpu_usage * 0.9)
+            share = cap / total_cap if total_cap > 0 else 0
+            r.cpu_usage = min(100.0, self._ep.current_load * share / cap * 100)
+            r.mem_usage = min(100.0, r.cpu_usage * 0.85)
         
         metrics = Metrics(
             avg_latency_ms=latency,