Merge branch 'main' into chathu01

agents/base_agent.py

@@ -31,19 +31,25 @@ class BaseAgent(ABC):
     def propose(self) -> List[Proposal]:
         """Return one Proposal per available sensor this agent controls."""
 
-    def update(self, reward: float, conflict_history: List[ConflictRecord]) -> None:
+    def update(self, reward: float, conflict_history: List) -> None:
+        """Accept ConflictRecord objects from interaction/conflict.py.
+        Uses involved_agents (not agents_involved) and has no resolution field.
+        """
         self.episode_reward += reward
         for record in conflict_history:
-            ctype = record.conflict_type
-            if self.agent_id in record.agents_involved:
-                if record.resolution == "command_override":
-                    self.losses[ctype] = self.losses.get(ctype, 0) + 1
+            # Support both interaction.conflict.ConflictRecord (dataclass) and
+            # env.models.ConflictRecord (Pydantic) by reading whichever field exists.
+            involved = (
+                getattr(record, "involved_agents", None)
+                or getattr(record, "agents_involved", [])
+            )
+            ctype = str(getattr(record, "conflict_type", "unknown"))
+            if self.agent_id in involved:
+                # Heuristic: first listed agent is the "winner" of the conflict
+                if involved and involved[0] == self.agent_id:
+                    self.wins[ctype] = self.wins.get(ctype, 0) + 1
                 else:
-                    # Won if we're not the one overridden — heuristic: first agent listed wins
-                    if record.agents_involved and record.agents_involved[0] == self.agent_id:
-                        self.wins[ctype] = self.wins.get(ctype, 0) + 1
-                    else:
-                        self.losses[ctype] = self.losses.get(ctype, 0) + 1
+                    self.losses[ctype] = self.losses.get(ctype, 0) + 1
         self.conflict_history.extend(conflict_history)
         self.conflict_history = self.conflict_history[-10:]
 

agents/command.py

@@ -108,21 +108,37 @@ class CommandAgent(BaseAgent):
         })
         return proposals
 
-    def issue_override(self, conflict: ConflictRecord) -> Optional[Proposal]:
-        """Called by resolver when conflict persists. Returns a binding override proposal."""
-        target_id = conflict.target_id
+    def issue_override(self, conflict) -> Optional[Proposal]:
+        """Called by resolver when conflict persists. Returns a binding override proposal.
+        Works with interaction.conflict.ConflictRecord (involved_targets/involved_agents)
+        and env.models.ConflictRecord (target_id/agents_involved).
+        """
+        # Resolve target_id from whichever schema is present
+        involved_targets = getattr(conflict, "involved_targets", None)
+        target_id = (
+            involved_targets[0]
+            if involved_targets
+            else getattr(conflict, "target_id", None)
+        )
+        if target_id is None:
+            return None
+
         target = next((t for t in self._active_targets() if t.id == target_id), None)
         if target is None:
             return None
 
+        # Resolve involved agents from whichever schema is present
+        involved = (
+            getattr(conflict, "involved_agents", None)
+            or getattr(conflict, "agents_involved", [])
+        )
+
         used_sensors = {p.sensor_id for p in self._all_proposals}
         free_sensor = next(
             (s for s in self._available_sensors() if s.id not in used_sensors), None
         )
 
         if free_sensor is None:
-            # Pick the proposal from the first involved agent to re-assign
-            involved = conflict.agents_involved
             override_prop = next(
                 (p for p in self._all_proposals
                  if p.agent_id in involved and p.target_id == target_id),

curriculum.py

@@ -110,6 +110,7 @@ class CurriculumEngine:
         Called after each episode with the episode's coordination and efficiency scores.
         Returns {"phase": int, "difficulty": float, "action": str}.
         """
+        self.episode_count += 1
         self._score_history.append(coordination_score)
         self._eff_history.append(efficiency_score)
 
@@ -181,10 +182,9 @@ class CurriculumEngine:
     # ── Episode lifecycle ────────────────────────────────────────────
     def reset_episode(self) -> None:
         """
-        Increment episode counter and check for self-play trigger.
-        Call at the start of each episode.
+        Called at the START of each episode to check for self-play triggers.
+        Does NOT increment episode_count — that is done by update() at episode end.
         """
-        self.episode_count += 1
         if self.should_trigger_self_play():
             self._self_play_triggers_count += 1
             logger.info(

env/dynamics.py

@@ -4,6 +4,7 @@ from typing import List
 from env.models import Sensor, Target
 
 SENSOR_TYPES = ["satellite", "drone", "radar"]
+TARGET_TYPES = ["strategic", "kinetic", "airspace"]
 
 
 def initialize_sensors(seed: int = 42) -> List[Sensor]:
@@ -34,7 +35,12 @@ def spawn_targets(
     rng = random.Random((seed * 6364136223846793005 + step) & 0xFFFFFFFFFFFFFFFF)
     count = rng.randint(2, 4)
     targets = [
-        Target(id=f"T{step}_{i+1}", priority=rng.randint(1, 3), active=True)
+        Target(
+            id=f"T{step}_{i+1}",
+            priority=rng.randint(1, 3),
+            active=True,
+            type=rng.choice(TARGET_TYPES),
+        )
         for i in range(count)
     ]
 
@@ -47,12 +53,17 @@ def spawn_targets(
         if injected:
             # Elevate existing target to P3
             targets = [
-                Target(id=t.id, priority=3 if t.id == overlap_id else t.priority, active=t.active)
+                Target(
+                    id=t.id,
+                    priority=3 if t.id == overlap_id else t.priority,
+                    active=t.active,
+                    type=t.type,
+                )
                 for t in targets
             ]
         else:
             # Prepend new P3 target in the overlap zone
-            targets = [Target(id=overlap_id, priority=3, active=True)] + targets
+            targets = [Target(id=overlap_id, priority=3, active=True, type=rng.choice(TARGET_TYPES))] + targets
 
     return targets
 
@@ -69,7 +80,12 @@ def spawn_targets_stochastic(step: int, seed: int = 42, density_factor: float =
         p *= rng.random()
     count = max(1, k - 1)
     return [
-        Target(id=f"T{step}_{i+1}", priority=rng.randint(1, 3), active=True)
+        Target(
+            id=f"T{step}_{i+1}",
+            priority=rng.randint(1, 3),
+            active=True,
+            type=rng.choice(TARGET_TYPES),
+        )
         for i in range(count)
     ]
 

env/environment.py

@@ -126,6 +126,9 @@ PRIORITY_REWARD = {3: 2.0, 2: 1.0, 1: 0.5}
 MISSED_HIGH_PENALTY = -2.0
 IDLE_PENALTY = -2.0
 
+# Stable per-agent salts — avoids hash() which is randomised per Python process
+_AGENT_SALT = {"satellite": 1001, "drone": 2002, "radar": 3003, "command": 4004}
+
 
 class AryaXEnv:
     def __init__(self, max_steps: int = 20, seed: int = 42, density_factor: float = 2.5,
@@ -222,7 +225,7 @@ class AryaXEnv:
         for agent_type in AGENT_TYPES:
             agent_sensors = [s for s in self.sensors if s.type == agent_type or agent_type == "command"]
             masked_targets = apply_mask(self.targets, agent_type, agent_sensors)
-            rng = random.Random(self.seed + self.current_step + hash(agent_type))
+            rng = random.Random(self.seed + self.current_step + _AGENT_SALT.get(agent_type, 0))
             noisy_targets = add_observation_noise(masked_targets, agent_type, rng)
             # Apply schema drift to noisy targets
             drifted = [Target(id=t.id, priority=priority_map.get(t.priority, t.priority), active=t.active)

env/models.py

@@ -13,6 +13,7 @@ class Target(BaseModel):
     id: str
     priority: int  # 1=low, 2=medium, 3=high
     active: bool
+    type: str = "strategic"  # "strategic" | "kinetic" | "airspace"
 
 
 class Observation(BaseModel):

env/multiagent.py

@@ -8,7 +8,7 @@ import random
 from typing import Dict, List, Optional, Tuple, Any
 from dataclasses import dataclass
 from env.models import Sensor, Target, Action
-from env.dynamics import initialize_sensors, spawn_targets
+from env.dynamics import initialize_sensors, spawn_targets, spawn_targets_stochastic, apply_correlated_failures
 from interaction import NegotiationLayer
 from interaction.reward import RewardEngine
 
@@ -53,11 +53,17 @@ def _cmd_override(tied: list[dict]) -> dict:
 # ── Multi-agent environment ───────────────────────────────────────────────────
 class AryaXEnv:
     def __init__(self, max_steps: int = 10, seed: int = 42,
-                 density_factor: float = 1.0, failure_prob: float = 0.0):
-        self.max_steps      = max_steps
-        self.seed           = seed
-        self.density_factor = density_factor
-        self.failure_prob   = failure_prob
+                 density_factor: float = 1.0, failure_prob: float = 0.0,
+                 conflict_injection: bool = False,
+                 min_targets: int = 0, max_targets: int = 0):
+        self.max_steps        = max_steps
+        self.seed             = seed
+        self.density_factor   = density_factor
+        self.failure_prob     = failure_prob
+        self.conflict_injection = conflict_injection
+        # When non-zero, clamp spawned target count to [min_targets, max_targets]
+        self.min_targets      = min_targets
+        self.max_targets      = max_targets
         self.sensors:    List[Sensor] = []
         self.targets:    List[Target] = []
         self.current_step: int = 0
@@ -68,9 +74,31 @@ class AryaXEnv:
         self.reward_engine  = RewardEngine()
         self._agent_rewards: Dict[str, float] = {a: 0.0 for a in AGENT_TYPES}
 
+    def _clamp_targets(self, targets: List[Target]) -> List[Target]:
+        """Enforce min/max target count from curriculum targets_per_step_range."""
+        if self.max_targets > 0 and len(targets) > self.max_targets:
+            targets = targets[:self.max_targets]
+        if self.min_targets > 0 and len(targets) < self.min_targets:
+            # Pad with copies of the highest-priority target
+            base = targets[-1] if targets else Target(id="T_pad_1", priority=1, active=True)
+            while len(targets) < self.min_targets:
+                pad = Target(
+                    id=f"{base.id}_pad{len(targets)}",
+                    priority=base.priority,
+                    active=True,
+                    type=base.type,
+                )
+                targets.append(pad)
+        return targets
+
     def reset(self) -> Dict[str, AgentObservation]:
         self.sensors = initialize_sensors(self.seed)
-        self.targets = spawn_targets(step=0, seed=self.seed)
+        if self.failure_prob > 0.0:
+            rng = random.Random(self.seed)
+            self.sensors = apply_correlated_failures(self.sensors, rng.randint(0, 9999), self.failure_prob)
+        self.targets = self._clamp_targets(
+            spawn_targets_stochastic(step=0, seed=self.seed, density_factor=self.density_factor)
+        )
         self.current_step = 0
         self._assignments = []
         self._missed = []
@@ -174,9 +202,23 @@ class AryaXEnv:
         )
 
         self.current_step += 1
-        self.targets = spawn_targets(step=self.current_step, seed=self.seed)
+        self.targets = self._clamp_targets(spawn_targets_stochastic(
+            step=self.current_step, seed=self.seed, density_factor=self.density_factor
+        ))
+        if self.conflict_injection:
+            # Guarantee at least one P3 target to exercise the conflict pipeline
+            from env.dynamics import spawn_targets as _spawn_det
+            injected = _spawn_det(step=self.current_step, seed=self.seed, conflict_injection=True)
+            p3_ids = {t.id for t in self.targets if t.priority == 3}
+            for t in injected:
+                if t.priority == 3 and t.id not in p3_ids:
+                    self.targets.append(t)
+                    break
         for s in self.sensors:
             s.available = True
+        if self.failure_prob > 0.0:
+            rng = random.Random(self.seed + self.current_step)
+            self.sensors = apply_correlated_failures(self.sensors, rng.randint(0, 9999), self.failure_prob)
 
         done = self.current_step >= self.max_steps
         conflict_rate = self.negotiation.get_conflict_rate()

env/reward.py

@@ -1,4 +0,0 @@
-"""
-NOTE: This file is deprecated.
-Reward logic is implemented directly in environment.py (step_batch).
-"""

pyproject.toml

@@ -19,6 +19,16 @@ dependencies = [
     "python-dotenv>=1.0.1",
 ]
 
+[project.optional-dependencies]
+training = [
+    "trl>=0.8.0",
+    "transformers>=4.40.0",
+    "peft>=0.10.0",
+    "torch",
+    "accelerate",
+    "bitsandbytes",
+]
+
 [project.scripts]
 server = "server.app:main"
 

requirements.txt

@@ -29,6 +29,18 @@ ffmpy==1.0.0
 filelock==3.25.2
 Flask==3.0.3
 Flask-Cors==4.0.1
+
+# ── Optional: training stack (GRPO/TRL) ──────────────────────────────────────
+# These are NOT installed by default. Install manually to enable trainer.py:
+#   pip install trl>=0.8.0 transformers>=4.40.0 peft>=0.10.0 torch accelerate bitsandbytes
+# On Colab with GPU: also install unsloth (see train_colab.py)
+# trl
+# transformers
+# peft
+# torch
+# accelerate
+# bitsandbytes
+# unsloth
 fsspec==2026.3.0
 gradio==6.11.0
 gradio_client==2.4.0

server.py

@@ -12,8 +12,6 @@ from flask import Flask, request, jsonify, render_template
 from env import SentinelEnv
 from env.models import Action
 from env.multiagent import AryaXEnv, Proposal, AGENT_TYPES
-from interaction import NegotiationLayer
-from interaction.reward import RewardEngine
 
 app = Flask(__name__)
 
@@ -23,10 +21,8 @@ obs = None
 _target_positions: dict = {}
 
 # ── Multi-agent env ───────────────────────────────────────────────────────────
-mx_env        = AryaXEnv(max_steps=10, seed=42)
-mx_obs        = None   # Dict[str, AgentObservation] | None
-_negotiation  = NegotiationLayer()
-_reward_eng   = RewardEngine()
+mx_env = AryaXEnv(max_steps=10, seed=42)
+mx_obs = None   # Dict[str, AgentObservation] | None
 
 # ── LLM client (optional) ─────────────────────────────────────────────────────
 _llm_client = None
@@ -198,26 +194,32 @@ def _build_multi_prompt(agent_id: str, agent_obs) -> str:
         f"  - id={t['id']} priority={t['priority']} active={t['active']}"
         for t in agent_obs.targets if t["active"]
     )
-    return f"""You are the {agent_id} agent in a multi-agent ISR system.
-Propose assignments for sensors you are responsible for.
-Priority 3=HIGH, 2=MED, 1=LOW. Cover HIGH threats first.
+    if not my_sensors:
+        return ""
+    sensor_ids = [s['id'] for s in my_sensors]
+    target_ids = [t['id'] for t in agent_obs.targets if t['active']]
+    return f"""You are the {agent_id} agent. Assign ONLY your sensors to threats.
+Your sensors: {sensor_ids}
+Active threat IDs: {target_ids}
+Priority 3=HIGH, 2=MED, 1=LOW. Cover HIGH first. Each sensor to a DIFFERENT target.
 
 Timestep: {agent_obs.timestep}
-Your agent type: {agent_id}
 
-Available Sensors:
+Your Sensors:
 {sensors}
 
 Active Threats:
 {targets}
 
-Respond ONLY with a JSON array:
-[{{"sensor_id": "S1", "target_id": "T0_1"}}]
+Respond ONLY with a JSON array using ONLY the sensor IDs and target IDs listed above:
+[{{"sensor_id": "{sensor_ids[0]}", "target_id": "{target_ids[0] if target_ids else 'T0_1'}"}}]
 """
 
 
-def _greedy_proposals(agent_id: str, agent_obs, used_sensors: set) -> list[Proposal]:
+def _greedy_proposals(agent_id: str, agent_obs, used_sensors: set, used_targets: set = None) -> list[Proposal]:
     """Greedy proposals for one agent — only claim sensors matching agent type."""
+    if used_targets is None:
+        used_targets = set()
     my_sensors = [
         s for s in agent_obs.sensors
         if s["available"] and s["id"] not in used_sensors
@@ -227,7 +229,7 @@ def _greedy_proposals(agent_id: str, agent_obs, used_sensors: set) -> list[Propo
         [t for t in agent_obs.targets if t["active"]],
         key=lambda t: -t["priority"]
     )
-    proposals, used_targets = [], set()
+    proposals = []
     for sensor in my_sensors:
         for target in targets:
             if target["id"] not in used_targets:
@@ -282,8 +284,10 @@ def _lora_multi_proposals(agent_obs_map) -> tuple[list[Proposal], str]:
 
 def _get_multi_proposals(agent_obs_map) -> tuple[list[Proposal], str]:
     """Build proposals from all agents. Returns (proposals, source)."""
+    import sys
     proposals: list[Proposal] = []
     used_sensors: set = set()
+    print(f"[_get_multi_proposals] called, llm_client={_llm_client is not None}", flush=True)
 
     if _has_adapters:
         return _lora_multi_proposals(agent_obs_map)
@@ -293,6 +297,9 @@ def _get_multi_proposals(agent_obs_map) -> tuple[list[Proposal], str]:
             for agent_id in AGENT_TYPES:
                 agent_obs = agent_obs_map[agent_id]
                 prompt = _build_multi_prompt(agent_id, agent_obs)
+                if not prompt:
+                    continue
+                print(f"[LLM multi] calling LLM for {agent_id}", flush=True)
                 response = _llm_client.chat.completions.create(
                     model=MODEL_NAME,
                     messages=[{"role": "user", "content": prompt}],
@@ -300,27 +307,38 @@ def _get_multi_proposals(agent_obs_map) -> tuple[list[Proposal], str]:
                     temperature=0.0
                 )
                 raw = response.choices[0].message.content.strip()
+                print(f"[LLM multi] {agent_id} response: {raw[:200]}", flush=True)
                 start, end = raw.find("["), raw.rfind("]") + 1
+                if start == -1 or end == 0:
+                    print(f"[LLM multi] {agent_id} no JSON array found", flush=True)
+                    continue
                 items = json.loads(raw[start:end])
-                valid_sensors = {s["id"] for s in agent_obs.sensors if s["available"]}
+                valid_sensors = {
+                    s["id"] for s in agent_obs.sensors
+                    if s["available"] and (agent_id == "command" or s["type"] == agent_id)
+                }
                 valid_targets = {t["id"] for t in agent_obs.targets if t["active"]}
                 for item in items:
                     sid, tid = item.get("sensor_id"), item.get("target_id")
-                    if sid in valid_sensors and tid in valid_targets:
+                    if sid in valid_sensors and tid in valid_targets and sid not in used_sensors:
                         proposals.append(Proposal(agent_id=agent_id, sensor_id=sid, target_id=tid))
                         used_sensors.add(sid)
             if proposals:
+                print(f"[LLM multi] Generated {len(proposals)} proposals", flush=True)
                 return proposals, "llm"
+            print("[LLM multi] No valid proposals, falling back to greedy", flush=True)
         except Exception as e:
-            print(f"[LLM multi] Error: {e}. Falling back to greedy.")
+            print(f"[LLM multi] Error: {e}. Falling back to greedy.", flush=True)
 
-    # Greedy fallback — agents claim sensors by type
+    # Greedy fallback — partition both sensors and targets across agents
     used_sensors = set()
+    used_targets: set = set()
     for agent_id in AGENT_TYPES:
         agent_obs = agent_obs_map[agent_id]
-        for p in _greedy_proposals(agent_id, agent_obs, used_sensors):
+        for p in _greedy_proposals(agent_id, agent_obs, used_sensors, used_targets):
             proposals.append(p)
             used_sensors.add(p.sensor_id)
+            used_targets.add(p.target_id)
 
     return proposals, "greedy"
 
@@ -449,8 +467,6 @@ def reset_multi():
     mx_env.seed      = seed
     mx_env.max_steps = max_steps
     mx_obs = mx_env.reset()
-    _negotiation.reset()
-    _reward_eng.reset()
     return jsonify({
         "seed":            seed,
         "max_steps":       max_steps,
@@ -479,113 +495,40 @@ def step_multi():
         if p.get("agent_id") and p.get("sensor_id") and p.get("target_id")
     ]
 
-    # Build world_state from satellite observation
-    sat_obs = mx_obs.get("satellite") or next(iter(mx_obs.values()))
-    sensors_dict  = sat_obs.sensors
-    targets_dict  = sat_obs.targets
-    proposals_raw = [
-        {"agent_id": p.agent_id, "sensor_id": p.sensor_id,
-         "target_id": p.target_id, "capability_score": 0.5}
-        for p in proposals
-    ]
-    assigned_sids = {p.sensor_id for p in proposals}
-    idle_sensors  = [s["id"] for s in sensors_dict if s["id"] not in assigned_sids]
-    world_state = {
-        "sensors":      sensors_dict,
-        "targets":      targets_dict,
-        "idle_sensors": idle_sensors,
-        "step":         sat_obs.timestep,
-        "proposals":    proposals_raw,
-    }
-
-    # Run NegotiationLayer (interaction/ package)
-    neg_result = _negotiation.negotiate(
-        proposals_raw, world_state, lambda tied: tied[0]
-    )
-
-    # Step env with resolved proposals
+    # Step env with proposals — env runs negotiation internally
     mx_obs, step_rewards, done, info = mx_env.step_multiagent(proposals)
 
-    # Compute per-agent rewards via RewardEngine
-    per_agent_rewards = _reward_eng.compute_step_reward(
-        neg_result.final_assignments, neg_result, world_state, list(AGENT_TYPES)
-    )
-
-    # Build conflict list from neg_result
-    conflicts = [
-        {
-            "type":      str(c.conflict_type),
-            "agents":    c.involved_agents,
-            "sensor_id": c.involved_sensors[0] if c.involved_sensors else None,
-            "target_id": c.involved_targets[0] if c.involved_targets else None,
-        }
-        for c in neg_result.conflicts_detected
-    ]
-    conflict_rate = _negotiation.get_conflict_rate()
+    # Extract conflict info from env's internal negotiation layer
+    conflict_rate = mx_env.negotiation.get_conflict_rate()
+    conflicts = info.get("conflicts", [])
 
     return jsonify({
         "observations":      {k: v.to_dict() for k, v in mx_obs.items()},
         "step_rewards":      step_rewards,
-        "per_agent_rewards": per_agent_rewards,
+        "per_agent_rewards": dict(mx_env._agent_rewards),
         "done":              done,
         "info":              info,
         "conflict_rate":     round(conflict_rate, 4),
         "conflicts":         conflicts,
-        "override_invoked":  neg_result.override_invoked,
+        "override_invoked":  False,
     })
 
 
 @app.post("/auto_multi")
 def auto_multi():
     global mx_obs
+    print(f"[auto_multi] called, mx_obs is None: {mx_obs is None}", flush=True)
     if mx_obs is None:
         return jsonify({"error": "Call /reset_multi first"}), 400
 
     proposals, source = _get_multi_proposals(mx_obs)
 
-    # Build world_state from satellite observation
-    sat_obs = mx_obs.get("satellite") or next(iter(mx_obs.values()))
-    sensors_dict  = sat_obs.sensors
-    targets_dict  = sat_obs.targets
-    proposals_raw = [
-        {"agent_id": p.agent_id, "sensor_id": p.sensor_id,
-         "target_id": p.target_id, "capability_score": 0.5}
-        for p in proposals
-    ]
-    assigned_sids = {p.sensor_id for p in proposals}
-    idle_sensors  = [s["id"] for s in sensors_dict if s["id"] not in assigned_sids]
-    world_state = {
-        "sensors":      sensors_dict,
-        "targets":      targets_dict,
-        "idle_sensors": idle_sensors,
-        "step":         sat_obs.timestep,
-        "proposals":    proposals_raw,
-    }
-
-    # Run NegotiationLayer (interaction/ package)
-    neg_result = _negotiation.negotiate(
-        proposals_raw, world_state, lambda tied: tied[0]
-    )
-
-    # Step env with resolved proposals (neg_result.final_assignments already validated)
+    # Step env with proposals — env runs negotiation internally
     mx_obs, step_rewards, done, info = mx_env.step_multiagent(proposals)
 
-    # Compute per-agent rewards via RewardEngine
-    per_agent_rewards = _reward_eng.compute_step_reward(
-        neg_result.final_assignments, neg_result, world_state, list(AGENT_TYPES)
-    )
-
-    # Build conflict list from neg_result
-    conflicts = [
-        {
-            "type":      str(c.conflict_type),
-            "agents":    c.involved_agents,
-            "sensor_id": c.involved_sensors[0] if c.involved_sensors else None,
-            "target_id": c.involved_targets[0] if c.involved_targets else None,
-        }
-        for c in neg_result.conflicts_detected
-    ]
-    conflict_rate = _negotiation.get_conflict_rate()
+    # Extract conflict info from env's internal negotiation layer
+    conflict_rate = mx_env.negotiation.get_conflict_rate()
+    conflicts = info.get("conflicts", [])
 
     return jsonify({
         "proposals":         [{"agent_id": p.agent_id, "sensor_id": p.sensor_id,
@@ -593,12 +536,12 @@ def auto_multi():
         "agent":             source,
         "observations":      {k: v.to_dict() for k, v in mx_obs.items()},
         "step_rewards":      step_rewards,
-        "per_agent_rewards": per_agent_rewards,
+        "per_agent_rewards": dict(mx_env._agent_rewards),
         "done":              done,
         "info":              info,
         "conflict_rate":     round(conflict_rate, 4),
         "conflicts":         conflicts,
-        "override_invoked":  neg_result.override_invoked,
+        "override_invoked":  False,
     })
 
 
@@ -610,5 +553,7 @@ def ui():
 
 
 if __name__ == "__main__":
+    import logging
+    logging.basicConfig(level=logging.INFO)
     port = int(os.environ.get("PORT", 7860))
-    app.run(host="0.0.0.0", port=port, debug=False, use_reloader=False)
+    app.run(host="0.0.0.0", port=port, debug=True, use_reloader=False)

tasks/easy_task.py

@@ -28,3 +28,8 @@ def get_easy_task():
 def get_easy_env():
     from env import SentinelEnv
     return SentinelEnv(max_steps=EASY_TASK_CONFIG["max_steps"], seed=42, config=EASY_TASK_CONFIG)
+
+
+def get_easy_multi_env():
+    from env.multiagent import AryaXEnv
+    return AryaXEnv(max_steps=EASY_TASK_CONFIG["max_steps"], seed=42, density_factor=1.5)

tasks/grader.py

@@ -127,100 +127,79 @@ def run_deterministic_eval(
     """
     try:
         from env.environment import SentinelEnv
-        from tasks.easy_task import get_easy_env
-        from tasks.medium_task import get_medium_env
-        from tasks.hard_task import get_hard_env
+        from env.multiagent import AryaXEnv
+        from tasks.easy_task import get_easy_env, get_easy_multi_env
+        from tasks.medium_task import get_medium_env, get_medium_multi_env
+        from tasks.hard_task import get_hard_env, get_hard_multi_env
     except ImportError as exc:
         raise ImportError(f"env/ or tasks/ package not found: {exc}") from exc
 
-    TASKS = [
-        ("easy",   get_easy_env,   42),
-        ("medium", get_medium_env, 7),
-        ("hard",   get_hard_env,   13),
-    ]
+    if mode == "multi":
+        TASKS = [
+            ("easy",   get_easy_multi_env,   42),
+            ("medium", get_medium_multi_env, 7),
+            ("hard",   get_hard_multi_env,   13),
+        ]
+    else:
+        TASKS = [
+            ("easy",   get_easy_env,   42),
+            ("medium", get_medium_env, 7),
+            ("hard",   get_hard_env,   13),
+        ]
 
     results: dict = {}
     all_scores: list[float] = []
     all_conflict_rates: list[float] = []
 
     for task_name, get_env_fn, seed in TASKS:
-        env: SentinelEnv = get_env_fn()
-        obs = env.reset()
-
         if mode == "multi":
-            # Multi-agent mode — uses NegotiationLayer + agents list
+            # Multi-agent mode — uses AryaXEnv + NegotiationLayer
             try:
                 from interaction import NegotiationLayer
                 from interaction.reward import RewardEngine
             except ImportError as exc:
                 raise ImportError(f"interaction/ package not found: {exc}") from exc
 
+            env: AryaXEnv = get_env_fn()
+            obs_map = env.reset()
             nl           = NegotiationLayer()
             reward_eng   = RewardEngine()
-            agent_ids    = ["SAT", "UAV", "RDR", "CMD"]
+            agent_ids    = ["satellite", "drone", "radar", "command"]
             total_rewards: dict[str, float] = {aid: 0.0 for aid in agent_ids}
             done         = False
 
             rng = __import__("random").Random(seed)
 
             while not done:
-                sensors_list = [
-                    {"id": s.id, "type": s.type, "range": s.range, "available": s.available}
-                    for s in obs.sensors
-                ]
-                targets_list = [
-                    {"id": t.id, "priority": t.priority, "active": t.active, "type": "strategic"}
-                    for t in obs.targets
-                ]
-
                 # Greedy proposals per agent
+                from env.multiagent import Proposal
                 proposals = []
-                available = [s for s in sensors_list if s.get("available", True)]
-                active_t  = sorted(
-                    [t for t in targets_list if t.get("active", True)],
-                    key=lambda t: -t.get("priority", 0),
-                )
                 used_sensors: set[str] = set()
                 used_targets: set[str] = set()
-                for i, aid in enumerate(agent_ids):
-                    if i < len(available) and active_t:
-                        sensor = available[i % len(available)]
-                        target = active_t[i % len(active_t)]
-                        if sensor["id"] not in used_sensors:
-                            proposals.append({
-                                "agent_id":          aid,
-                                "sensor_id":         sensor["id"],
-                                "target_id":         target["id"],
-                                "priority_estimate": target.get("priority", 1),
-                                "confidence":        0.8,
-                                "capability_score":  0.7,
-                            })
-                            used_sensors.add(sensor["id"])
-
-                assigned_sids = {p["sensor_id"] for p in proposals}
-                idle_sensors  = [s["id"] for s in sensors_list if s["id"] not in assigned_sids]
-
-                world_state = {
-                    "sensors":      sensors_list,
-                    "targets":      targets_list,
-                    "idle_sensors": idle_sensors,
-                    "step":         env.current_step,
-                    "proposals":    proposals,
-                }
-
-                def _cmd_fn(tied):
-                    return max(tied, key=lambda p: p.get("capability_score", 0.0))
-
-                neg_result = nl.negotiate(proposals, world_state, _cmd_fn)
-                env_actions = [
-                    {"sensor_id": a["sensor_id"], "target_id": a["target_id"]}
-                    for a in neg_result.final_assignments
-                ]
-                obs, _, done, _ = env.step_batch(env_actions)
-
-                step_r = reward_eng.compute_step_reward(
-                    neg_result.final_assignments, neg_result, world_state, agent_ids
-                )
+                for agent_id in agent_ids:
+                    agent_obs = obs_map[agent_id]
+                    my_sensors = [
+                        s for s in agent_obs.sensors
+                        if s["available"] and s["id"] not in used_sensors
+                        and (agent_id == "command" or s["type"] == agent_id)
+                    ]
+                    targets = sorted(
+                        [t for t in agent_obs.targets if t["active"]],
+                        key=lambda t: -t["priority"]
+                    )
+                    for sensor in my_sensors:
+                        for target in targets:
+                            if target["id"] not in used_targets:
+                                proposals.append(Proposal(
+                                    agent_id=agent_id,
+                                    sensor_id=sensor["id"],
+                                    target_id=target["id"]
+                                ))
+                                used_sensors.add(sensor["id"])
+                                used_targets.add(target["id"])
+                                break
+
+                obs_map, step_r, done, info = env.step_multiagent(proposals)
                 for aid, r in step_r.items():
                     total_rewards[aid] += r
 
@@ -228,7 +207,7 @@ def run_deterministic_eval(
                 per_agent_rewards=total_rewards,
                 step_count=env.max_steps,
                 num_sensors=env.initial_sensor_count,
-                negotiation_layer=nl,
+                negotiation_layer=env.negotiation,
                 num_agents=4,
             )
             all_scores.append(task_result["overall_score"])
@@ -236,6 +215,8 @@ def run_deterministic_eval(
 
         else:
             # Single-agent mode — uses greedy baseline policy
+            env: SentinelEnv = get_env_fn()
+            obs = env.reset()
             try:
                 from agent.policy import select_action
             except ImportError:

tasks/hard_task.py

@@ -61,3 +61,8 @@ def get_hard_task():
 def get_hard_env():
     from env import SentinelEnv
     return SentinelEnv(max_steps=HARD_TASK_CONFIG["max_steps"], seed=13, config=HARD_TASK_CONFIG)
+
+
+def get_hard_multi_env():
+    from env.multiagent import AryaXEnv
+    return AryaXEnv(max_steps=HARD_TASK_CONFIG["max_steps"], seed=13, density_factor=4.0, failure_prob=0.15, conflict_injection=True)

tasks/medium_task.py

@@ -45,3 +45,8 @@ def get_medium_task():
 def get_medium_env():
     from env import SentinelEnv
     return SentinelEnv(max_steps=MEDIUM_TASK_CONFIG["max_steps"], seed=7, config=MEDIUM_TASK_CONFIG)
+
+
+def get_medium_multi_env():
+    from env.multiagent import AryaXEnv
+    return AryaXEnv(max_steps=MEDIUM_TASK_CONFIG["max_steps"], seed=7, density_factor=2.5, conflict_injection=True)

test_integration.py

@@ -0,0 +1,278 @@
+"""
+ARYA-X Full Integration Test
+Tests every module connection described in the spec.
+"""
+import sys
+import traceback
+
+PASS = []
+FAIL = []
+
+def check(name, fn):
+    try:
+        fn()
+        PASS.append(name)
+        print(f"  PASS  {name}")
+    except Exception as e:
+        FAIL.append((name, str(e)))
+        print(f"  FAIL  {name}")
+        print(f"        {e}")
+
+# ── 1. Core imports ────────────────────────────────────────────────────────────
+check("env/__init__ exports SentinelEnv", lambda: __import__("env").SentinelEnv)
+check("env.models all 6 models", lambda: [
+    getattr(__import__("env.models", fromlist=["Sensor"]), x)
+    for x in ["Sensor","Target","Observation","Action","Proposal","AgentObservation","ConflictRecord","EpisodeMetrics"]
+])
+check("env.dynamics all 4 functions", lambda: [
+    getattr(__import__("env.dynamics", fromlist=["initialize_sensors"]), x)
+    for x in ["initialize_sensors","spawn_targets","spawn_targets_stochastic","apply_correlated_failures"]
+])
+check("env.world_model all 3 functions", lambda: [
+    getattr(__import__("env.world_model", fromlist=["add_observation_noise"]), x)
+    for x in ["add_observation_noise","apply_mask","get_priority_mapping"]
+])
+check("interaction package all 4 classes", lambda: [
+    getattr(__import__("interaction", fromlist=["NegotiationLayer"]), x)
+    for x in ["NegotiationLayer","ConflictDetector","ConflictResolver","RewardEngine"]
+])
+check("agents package all 4 agents", lambda: [
+    getattr(__import__("agents", fromlist=["SatelliteAgent"]), x)
+    for x in ["SatelliteAgent","DroneAgent","RadarAgent","CommandAgent"]
+])
+check("curriculum.CurriculumEngine", lambda: __import__("curriculum").CurriculumEngine)
+check("trainer.ARYAXTrainer importable", lambda: __import__("trainer").ARYAXTrainer)
+check("tasks.grader all 3 functions", lambda: [
+    getattr(__import__("tasks.grader", fromlist=["grade_episode"]), x)
+    for x in ["grade_episode","grade_multi_agent_episode","run_deterministic_eval"]
+])
+
+# ── 2. env/environment.py — both AryaXEnv classes ─────────────────────────────
+check("env.environment.SentinelEnv exists", lambda: __import__("env.environment", fromlist=["SentinelEnv"]).SentinelEnv)
+check("env.environment.AryaXEnv (rich) exists", lambda: __import__("env.environment", fromlist=["AryaXEnv"]).AryaXEnv)
+check("env.multiagent.AryaXEnv (server) exists", lambda: __import__("env.multiagent", fromlist=["AryaXEnv"]).AryaXEnv)
+
+# ── 3. SentinelEnv full episode ────────────────────────────────────────────────
+def _sentinel_episode():
+    from env.environment import SentinelEnv
+    env = SentinelEnv(max_steps=3, seed=42)
+    obs = env.reset()
+    assert obs.sensors and obs.targets
+    from env.models import Action
+    obs, r, done, info = env.step(Action(sensor_id=obs.sensors[0].id, target_id=obs.targets[0].id))
+    assert "step_count" in info
+check("SentinelEnv reset/step/info", _sentinel_episode)
+
+# ── 4. env.environment.AryaXEnv (rich) — partial obs + world model ────────────
+def _rich_aryax():
+    from env.environment import AryaXEnv
+    env = AryaXEnv(max_steps=3, seed=42, density_factor=2.5, failure_prob=0.1)
+    obs_map = env.reset()
+    assert set(obs_map.keys()) == {"satellite","drone","radar","command"}
+    # Each agent gets different target counts (partial obs)
+    sat_t = len(obs_map["satellite"].targets)
+    drone_t = len(obs_map["drone"].targets)
+    # satellite sees all, drone sees subset — may differ
+    assert sat_t >= 0 and drone_t >= 0
+check("env.environment.AryaXEnv partial obs + world model", _rich_aryax)
+
+# ── 5. env.multiagent.AryaXEnv (server) — interaction/ pipeline ───────────────
+def _server_aryax():
+    from env.multiagent import AryaXEnv, Proposal
+    env = AryaXEnv(max_steps=3, seed=42)
+    obs = env.reset()
+    proposals = [
+        Proposal(agent_id="satellite", sensor_id=obs["satellite"].sensors[0]["id"],
+                 target_id=obs["satellite"].targets[0]["id"]),
+    ]
+    obs2, rewards, done, info = env.step_multiagent(proposals)
+    assert "conflict_rate" in info
+    assert "step_rewards" in info
+    assert set(rewards.keys()) == {"satellite","drone","radar","command"}
+check("env.multiagent.AryaXEnv step_multiagent + conflict_rate", _server_aryax)
+
+# ── 6. interaction/ pipeline end-to-end ───────────────────────────────────────
+def _interaction_pipeline():
+    from interaction import NegotiationLayer
+    from interaction.reward import RewardEngine
+    nl = NegotiationLayer()
+    re = RewardEngine()
+    proposals = [
+        {"agent_id":"satellite","sensor_id":"S1","target_id":"T0_1","capability_score":0.9},
+        {"agent_id":"drone",    "sensor_id":"S2","target_id":"T0_1","capability_score":0.5},  # conflict
+    ]
+    world_state = {
+        "sensors": [{"id":"S1","type":"satellite","range":500,"available":True},
+                    {"id":"S2","type":"drone","range":100,"available":True}],
+        "targets": [{"id":"T0_1","priority":3,"active":True,"type":"strategic"},
+                    {"id":"T0_2","priority":1,"active":True,"type":"airspace"}],
+        "idle_sensors": [],
+        "step": 0,
+        "proposals": proposals,
+    }
+    result = nl.negotiate(proposals, world_state, lambda tied: max(tied, key=lambda p: p.get("capability_score",0)))
+    assert len(result.conflicts_detected) > 0, "Expected conflict"
+    assert nl.get_conflict_rate() > 0
+    rewards = re.compute_step_reward(result.final_assignments, result, world_state, ["satellite","drone","radar","command"])
+    assert isinstance(rewards, dict)
+check("interaction/ NegotiationLayer + RewardEngine pipeline", _interaction_pipeline)
+
+# ── 7. agents/ — observe/propose interface ────────────────────────────────────
+def _agents_propose():
+    from agents import SatelliteAgent, DroneAgent, RadarAgent, CommandAgent
+    from env.models import AgentObservation, Sensor, Target
+    sensors = [Sensor(id="S1", type="satellite", range=500, available=True)]
+    targets = [Target(id="T0_1", priority=3, active=True),
+               Target(id="T0_2", priority=2, active=True)]
+    obs = AgentObservation(agent_id="satellite", agent_type="satellite",
+                           sensors=sensors, targets=targets, timestep=0)
+    sat = SatelliteAgent()
+    sat.observe(obs)
+    props = sat.propose()
+    assert isinstance(props, list)
+
+    drone_obs = AgentObservation(agent_id="drone", agent_type="drone",
+                                 sensors=[Sensor(id="S2",type="drone",range=100,available=True)],
+                                 targets=targets, timestep=0)
+    d = DroneAgent()
+    d.observe(drone_obs)
+    assert isinstance(d.propose(), list)
+
+    radar_obs = AgentObservation(agent_id="radar", agent_type="radar",
+                                 sensors=[Sensor(id="S3",type="radar",range=300,available=True)],
+                                 targets=targets, timestep=0)
+    r = RadarAgent()
+    r.observe(radar_obs)
+    assert isinstance(r.propose(), list)
+
+    cmd_obs = AgentObservation(agent_id="command", agent_type="command",
+                               sensors=sensors, targets=targets, timestep=0)
+    c = CommandAgent()
+    c.observe(cmd_obs)
+    assert isinstance(c.propose(), list)
+check("agents/ all 4 observe()+propose() callable", _agents_propose)
+
+# ── 8. CommandAgent.observe() accepts proposals kwarg ─────────────────────────
+def _cmd_proposals_kwarg():
+    from agents import CommandAgent
+    from env.models import AgentObservation, Sensor, Target, Proposal
+    sensors = [Sensor(id="S1",type="satellite",range=500,available=True)]
+    targets = [Target(id="T0_1",priority=3,active=True)]
+    obs = AgentObservation(agent_id="command",agent_type="command",
+                           sensors=sensors,targets=targets,timestep=0)
+    existing = [Proposal(sensor_id="S1",target_id="T0_1",agent_id="satellite",
+                         priority_estimate=3,confidence=0.9)]
+    c = CommandAgent()
+    c.observe(obs, proposals=existing)
+    props = c.propose()
+    assert isinstance(props, list)
+check("CommandAgent.observe(obs, proposals=...) signature", _cmd_proposals_kwarg)
+
+# ── 9. DroneAgent theory-of-mind (loss tracking) ──────────────────────────────
+def _drone_tom():
+    from agents import DroneAgent
+    from env.models import AgentObservation, Sensor, Target, ConflictRecord
+    sensors = [Sensor(id="S2",type="drone",range=100,available=True)]
+    targets = [Target(id="T0_2",priority=2,active=True)]
+    obs = AgentObservation(agent_id="drone",agent_type="drone",
+                           sensors=sensors,targets=targets,timestep=0)
+    d = DroneAgent()
+    d.observe(obs)
+    # Simulate 3 losses to radar on redundant_coverage
+    d.losses["redundant_coverage"] = 3
+    props = d.propose()
+    # Boundary target (even index) should have reduced confidence
+    boundary_props = [p for p in props if d._is_boundary_target(p.target_id)]
+    if boundary_props:
+        assert boundary_props[0].confidence <= 0.5
+check("DroneAgent theory-of-mind confidence reduction", _drone_tom)
+
+# ── 10. CurriculumEngine → AryaXEnv config connection ─────────────────────────
+def _curriculum_to_env():
+    from curriculum import CurriculumEngine
+    from env.multiagent import AryaXEnv
+    ce = CurriculumEngine()
+    cfg = ce.get_scenario_config()
+    assert "max_steps" in cfg
+    assert "sensor_failure_prob" in cfg
+    env = AryaXEnv(
+        max_steps=cfg["max_steps"],
+        seed=42,
+        density_factor=1.5 + ce.difficulty_level * 2.5,
+        failure_prob=cfg["sensor_failure_prob"],
+    )
+    obs = env.reset()
+    assert obs is not None
+check("CurriculumEngine config -> AryaXEnv constructor", _curriculum_to_env)
+
+# ── 11. grader.grade_multi_agent_episode ──────────────────────────────────────
+def _grader_multi():
+    from tasks.grader import grade_multi_agent_episode
+    from interaction import NegotiationLayer
+    nl = NegotiationLayer()
+    result = grade_multi_agent_episode(
+        per_agent_rewards={"SAT":10.0,"UAV":5.0,"RDR":3.0,"CMD":2.0},
+        step_count=20,
+        num_sensors=4,
+        negotiation_layer=nl,
+        num_agents=4,
+    )
+    assert "overall_score" in result
+    assert "coordination_score" in result
+    assert "conflict_rate" in result
+check("grader.grade_multi_agent_episode", _grader_multi)
+
+# ── 12. server.py imports cleanly ─────────────────────────────────────────────
+check("server.py imports without error", lambda: __import__("server"))
+
+# ── 13. inference.py imports + run_multi_task callable ────────────────────────
+def _inference_multi():
+    import inference
+    assert callable(inference.run_multi_task)
+    assert callable(inference._greedy_multi_proposals)
+check("inference.py run_multi_task callable", _inference_multi)
+
+# ── 14. trainer.py ARYAXTrainer instantiates (no model) ──────────────────────
+def _trainer_init():
+    from trainer import ARYAXTrainer
+    # Should not raise even without GPU/model
+    t = ARYAXTrainer.__new__(ARYAXTrainer)
+    t.curriculum = __import__("curriculum").CurriculumEngine()
+    from interaction import NegotiationLayer
+    from interaction.reward import RewardEngine
+    t.negotiation = NegotiationLayer()
+    t.reward_engine = RewardEngine()
+    t._grpo_trainer = None
+    assert t._grpo_trainer is None
+check("ARYAXTrainer attributes accessible", _trainer_init)
+
+# ── 15. tasks/ easy/medium/hard envs return SentinelEnv ───────────────────────
+def _task_envs():
+    from tasks.easy_task import get_easy_env
+    from tasks.medium_task import get_medium_env
+    from tasks.hard_task import get_hard_env
+    from env.environment import SentinelEnv
+    for fn in [get_easy_env, get_medium_env, get_hard_env]:
+        e = fn()
+        assert isinstance(e, SentinelEnv)
+        obs = e.reset()
+        assert obs.sensors
+check("tasks/ easy/medium/hard envs", _task_envs)
+
+# ── 16. env.multiagent NegotiationLayer is interaction/ (not duplicate) ────────
+def _no_duplicate_nl():
+    from env.multiagent import NegotiationLayer as MaNL
+    from interaction import NegotiationLayer as INL
+    assert MaNL is INL, "env.multiagent.NegotiationLayer must BE interaction.NegotiationLayer"
+check("env.multiagent.NegotiationLayer IS interaction.NegotiationLayer (no duplicate)", _no_duplicate_nl)
+
+# ── Summary ────────────────────────────────────────────────────────────────────
+print(f"\n{'='*55}")
+print(f"  PASSED: {len(PASS)}/{len(PASS)+len(FAIL)}")
+if FAIL:
+    print(f"  FAILED: {len(FAIL)}")
+    for name, err in FAIL:
+        print(f"    - {name}")
+        print(f"      {err}")
+print(f"{'='*55}")
+sys.exit(0 if not FAIL else 1)

train_colab.py

@@ -252,14 +252,11 @@ for ep in range(1, NUM_EPISODES + 1):
     if grpo_trainer is not None and proposals:
         queries   = [json.dumps({"sensors": env_state["sensors"], "step": ep}) for _ in proposals]
         responses = [json.dumps(p) for p in proposals]
-        try:
-            grpo_trainer.step(
-                queries=queries,
-                completions=responses,
-                rewards=[ep_reward / max(len(proposals), 1)] * len(proposals),
-            )
-        except Exception as _e:
-            pass  # graceful degradation if TRL API differs
+        grpo_trainer.step(
+            queries=queries,
+            responses=responses,
+            rewards=[ep_reward / max(len(proposals), 1)] * len(proposals),
+        )
 
     if ep % 5 == 0 or ep == 1:
         print(

trainer.py

@@ -295,17 +295,24 @@ class ARYAXTrainer:
 
         for episode in range(1, self.num_episodes + 1):
             # ── Phase 1: Episode rollout ──────────────────────────
+            # reset_episode() only checks self-play triggers; episode_count
+            # is incremented once by update() at episode end.
             self.curriculum.reset_episode()
             cfg = self.curriculum.get_scenario_config()
 
             ep_seed = cfg.get("seed_override") or rng.randint(0, 10000)
             conflict_injection = cfg.get("conflict_injection", False)
+            targets_range = cfg.get("targets_per_step_range", (0, 0))
+            freeze_agent = cfg.get("freeze_agent")
 
             env = AryaXEnv(
                 max_steps=cfg["max_steps"],
                 seed=ep_seed,
                 density_factor=1.5 + self.curriculum.difficulty_level * 2.5,
                 failure_prob=cfg["sensor_failure_prob"],
+                conflict_injection=cfg["conflict_injection"],
+                min_targets=targets_range[0],
+                max_targets=targets_range[1],
             )
             # ── PARTIAL OBSERVABILITY: use AryaXEnv.reset() → per-agent obs ──
             obs_map = env.reset()   # Dict[agent_id → AgentObservation (dataclass)]
@@ -332,11 +339,11 @@ class ARYAXTrainer:
                 targets_list_by_agent: dict[str, list] = {}
 
                 # First pass: satellite, drone, radar observe & propose
+                # Frozen agent (self-play curriculum) skips propose() entirely
                 for canonical_id in ["satellite", "drone", "radar"]:
                     agent = self._agents[canonical_id]
-                    agent_obs = obs_map[canonical_id]  # AgentObservation dataclass
+                    agent_obs = obs_map[canonical_id]
 
-                    # Build models.AgentObservation for the agent's observe() method
                     from env.models import AgentObservation as ModelAgentObs, Sensor as ModelSensor, Target as ModelTarget
                     model_obs = ModelAgentObs(
                         agent_id=canonical_id,
@@ -347,7 +354,13 @@ class ARYAXTrainer:
                         conflict_history=[],
                     )
                     agent.observe(model_obs)
-                    proposals_obj = agent.propose()
+                    # freeze_agent uses short-code (SAT/UAV/RDR); map to canonical
+                    _freeze_map = {"SAT": "satellite", "UAV": "drone", "RDR": "radar"}
+                    frozen_canonical = _freeze_map.get(freeze_agent)
+                    if frozen_canonical == canonical_id:
+                        proposals_obj = []  # frozen — contributes nothing this step
+                    else:
+                        proposals_obj = agent.propose()
                     all_proposals_obj.extend(proposals_obj)
 
                     sensors_list_by_agent[canonical_id] = agent_obs.sensors
@@ -418,14 +431,16 @@ class ARYAXTrainer:
                 for canonical_id in AGENT_TYPES:
                     episode_rewards[canonical_id] += step_rewards.get(canonical_id, 0.0)
 
-                # Update agent conflict history
-                for conflict in neg_result.conflicts_detected:
-                    for canonical_id in AGENT_TYPES:
-                        if canonical_id in (conflict.involved_agents or []):
-                            self._agents[canonical_id].update(
-                                step_rewards.get(canonical_id, 0.0),
-                                []
-                            )
+                # Update agent conflict history with real conflict records
+                for canonical_id in AGENT_TYPES:
+                    agent_conflicts = [
+                        c for c in neg_result.conflicts_detected
+                        if canonical_id in (getattr(c, "involved_agents", []) or [])
+                    ]
+                    self._agents[canonical_id].update(
+                        step_rewards.get(canonical_id, 0.0),
+                        agent_conflicts
+                    )
 
                 # Store GRPO experiences (keyed by short AGENT_IDS for backward compat)
                 for short_id in AGENT_IDS:
@@ -492,6 +507,8 @@ class ARYAXTrainer:
                 "difficulty":         round(curr_update["difficulty"], 3),
                 "phase":              curr_update["phase"],
                 "conflict_injection": conflict_injection,
+                "targets_range":      list(targets_range),
+                "freeze_agent":       freeze_agent,
             })
             # Flush metrics every 10 episodes (avoid losing data on crash)
             if episode % 10 == 0:
@@ -586,7 +603,7 @@ class ARYAXTrainer:
             try:
                 self._grpo_trainer.step(
                     queries=list(queries),
-                    completions=list(responses),
+                    responses=list(responses),
                     rewards=advantages,
                 )
                 print(
@@ -606,7 +623,7 @@ class ARYAXTrainer:
         try:
             from tasks.grader import run_deterministic_eval
             # Pass None since we are using greedy agents, not LLM agents
-            result = run_deterministic_eval(agents=None, verbose=True, mode="single")
+            result = run_deterministic_eval(agents=None, verbose=True, mode="multi")
             conflict_rate      = self.negotiation.get_conflict_rate()
             coordination_score = 1.0 - conflict_rate
             result["conflict_rate"]      = conflict_rate