added VIP nodes, which have a higher weightage

client.py

@@ -79,10 +79,12 @@ class AntiAtroposEnv(
             NodeObservation(
                 node_id=n.get("node_id", ""),
                 status=NodeStatus(n.get("status", NodeStatus.HEALTHY)),
+                is_vip=n.get("is_vip", False),
                 queue_depth=n.get("queue_depth", 0),
                 latency_ms=n.get("latency_ms", 0.0),
                 incoming_request_rate=n.get("incoming_request_rate", 0.0),
                 cpu_utilization=n.get("cpu_utilization", 0.0),
+                importance_weight=n.get("importance_weight", 1.0),
                 done=n.get("done", False),
                 reward=n.get("reward", 0.0),
             )
@@ -102,6 +104,8 @@ class AntiAtroposEnv(
             step=obs_data.get("step", 0),
             max_steps=obs_data.get("max_steps", 100),
             sla_violations=obs_data.get("sla_violations", 0),
+            invalid_action_count=obs_data.get("invalid_action_count", 0),
+            vip_failure_count=obs_data.get("vip_failure_count", 0),
             done=payload.get("done", False),
             reward=payload.get("reward", 0.0),
         )

models.py

@@ -40,6 +40,7 @@ class NodeObservation(BaseModel):
     """Telemetry for a single service instance (node)."""
     node_id: str
     status: NodeStatus
+    is_vip: bool = False
     
     # All numerical telemetry is normalized to [0, 1] for RL stability.
     queue_depth: float = Field(
@@ -72,6 +73,12 @@ class NodeObservation(BaseModel):
         description="Estimated CPU load [0.0, 1.0].",
     )
 
+    importance_weight: float = Field(
+        default=1.0,
+        ge=0.0,
+        description="Business criticality weight. VIP nodes have higher impact on scoring.",
+    )
+
     # Episode interaction fields (handled by framework)
     done: bool = False
     reward: float = 0.0
@@ -129,6 +136,11 @@ class ClusterObservation(BaseModel):
         description="Number of forbidden actions (e.g. SHED_LOAD on critical nodes).",
     )
 
+    vip_failure_count: int = Field(
+        default=0,
+        description="Number of failed VIP nodes in the current observation.",
+    )
+
     nodes: list[NodeObservation]
 
     # Episode interaction fields (handled by framework)

server/AntiAtropos_environment.py

@@ -156,24 +156,38 @@ class AntiAtroposEnvironment(Environment):
         return total_capacity_units * COST_PER_CAPACITY_UNIT_PER_HOUR
 
     def _avg_latency(self, nodes: list[dict]) -> float:
-        """Computes mean latency across all non-failed nodes."""
-        active = [n for n in nodes if n["status"] != NodeStatus.FAILED]
-        if not active:
+        """Computes importance-weighted mean latency across the cluster."""
+        if not nodes:
             return float("inf")
-        return sum(n["latency_ms"] for n in active) / len(active)
+
+        weighted_latency = 0.0
+        total_weight = 0.0
+        for n in nodes:
+            weight = float(n.get("importance_weight", 1.0))
+            latency = MAX_LATENCY_NORM if n["status"] == NodeStatus.FAILED else float(n["latency_ms"])
+            weighted_latency += weight * latency
+            total_weight += weight
+
+        if total_weight <= 0:
+            return float("inf")
+        return weighted_latency / total_weight
 
     def _error_rate(self, nodes: list[dict]) -> float:
-        """Calculates the cluster-wide fraction of dropped or lost requests."""
-        total_incoming = sum(n.get("incoming_request_rate", 0.0) for n in nodes)
+        """Calculates an importance-weighted fraction of dropped or lost requests."""
+        total_incoming = sum(float(n.get("incoming_request_rate", 0.0)) * float(n.get("importance_weight", 1.0)) for n in nodes)
         if total_incoming <= 0:
             return 0.0
 
         # dropped_requests already includes both:
         # - explicit shedding (SHED_LOAD)
         # - traffic sent to FAILED nodes in simulator._update_queues
-        total_drops = sum(n.get("dropped_requests", 0.0) for n in nodes)
+        total_drops = sum(float(n.get("dropped_requests", 0.0)) * float(n.get("importance_weight", 1.0)) for n in nodes)
         return min(1.0, total_drops / total_incoming)
 
+    def _vip_failure_count(self, nodes: list[dict]) -> int:
+        """Counts failed VIP nodes for reporting and diagnostics."""
+        return sum(1 for n in nodes if n.get("is_vip") and n["status"] == NodeStatus.FAILED)
+
     def _build_observation(self) -> ClusterObservation:
         """Assembles the ClusterObservation from the current observed simulator state."""
         node_obs = [
@@ -184,6 +198,8 @@ class AntiAtroposEnvironment(Environment):
                 latency_ms=min(1.0, max(0.0, float(n["latency_ms"]) / MAX_LATENCY_NORM)),
                 incoming_request_rate=min(1.0, max(0.0, float(n["incoming_request_rate"]) / MAX_REQUEST_RATE_NORM)),
                 cpu_utilization=min(1.0, max(0.0, float(n["cpu_utilization"]))),
+                is_vip=bool(n.get("is_vip", False)),
+                importance_weight=float(n.get("importance_weight", 1.0)),
                 done=False,
                 reward=0.0,
             )
@@ -207,6 +223,7 @@ class AntiAtroposEnvironment(Environment):
             max_steps=MAX_STEPS,
             sla_violations=self._sla_violations,
             invalid_action_count=self._sim.invalid_action_count,
+            vip_failure_count=self._vip_failure_count(self._nodes_true),
             done=False,
             reward=0.0,
         )

simulator.py

@@ -59,6 +59,12 @@ T3_SURGE_MAGNITUDE:    float = 70.0 # Extra req/tick added to node-1 and node-2
 # In Task 3, these receive the surge. Forcing the agent to SCALE.
 CRITICAL_NODES: list[str] = ["node-0", "node-1", "node-2"]
 
+# VIP / business-critical node weights.
+# node-0 is the payment portal, so its queue growth or failure matters more.
+VIP_NODE_WEIGHTS: dict[str, float] = {
+    "node-0": 4.0,
+}
+
 
 class NodeStatus(str, Enum):
     HEALTHY  = "HEALTHY"
@@ -70,9 +76,11 @@ class NodeStatus(str, Enum):
 class NodeState:
     node_id: str
     status: NodeStatus = NodeStatus.HEALTHY
+    is_vip: bool = False
     
     # Physics parameters
     capacity: float = DEFAULT_CAPACITY
+    importance_weight: float = 1.0
     queue_depth: float = 0.0
     latency_ms: float = BASE_LATENCY_MS
     incoming_request_rate: float = 0.0
@@ -95,7 +103,9 @@ class NodeState:
         return {
             "node_id": self.node_id,
             "status": self.status,
+            "is_vip": self.is_vip,
             "capacity": self.capacity,
+            "importance_weight": self.importance_weight,
             "queue_depth": int(self.queue_depth),
             "latency_ms": round(self.latency_ms, 2),
             "incoming_request_rate": round(self.incoming_request_rate, 2),
@@ -161,7 +171,11 @@ class ClusterSimulator:
 
     def _reset_nodes(self) -> None:
         self._nodes = [
-            NodeState(node_id=f"node-{i}") 
+            NodeState(
+                node_id=f"node-{i}",
+                is_vip=f"node-{i}" in VIP_NODE_WEIGHTS,
+                importance_weight=VIP_NODE_WEIGHTS.get(f"node-{i}", 1.0),
+            )
             for i in range(self._n_nodes)
         ]
 

stability.py

@@ -75,7 +75,12 @@ def compute_lyapunov(nodes: list[dict]) -> float:
     Returns:
         Scalar Lyapunov energy  ≥ 0.
     """
-    return float(sum(n["queue_depth"] ** 2 for n in nodes))
+    return float(
+        sum(
+            float(n.get("importance_weight", 1.0)) * (n["queue_depth"] ** 2)
+            for n in nodes
+        )
+    )
 
 
 def compute_drift(v_prev: float, v_curr: float) -> float: