cogames 0.3.64__py3-none-any.whl → 0.3.68__py3-none-any.whl

cogames/cogs_vs_clips/cog.py

@@ -2,14 +2,20 @@ from __future__ import annotations
 
 from pydantic import Field
 
+from cogames.cogs_vs_clips.config import CvCConfig
 from mettagrid.base_config import Config
+from mettagrid.config.game_value import InventoryValue
+from mettagrid.config.game_value import stat as game_stat
 from mettagrid.config.handler_config import Handler
 from mettagrid.config.mettagrid_config import (
     AgentConfig,
     InventoryConfig,
     ResourceLimitsConfig,
 )
+from mettagrid.config.mutation.game_value_mutation import SetGameValueMutation
+from mettagrid.config.mutation.mutation import EntityTarget
 from mettagrid.config.mutation.resource_mutation import updateActor
+from mettagrid.config.reward_config import reward
 
 
 class CogConfig(Config):
@@ -32,48 +38,60 @@ class CogConfig(Config):
     # Initial inventory
     initial_energy: int = Field(default=100)
     initial_hp: int = Field(default=50)
+    initial_solar: int = Field(default=1)
 
     # Regen amounts
-    energy_regen: int = Field(default=1)
     hp_regen: int = Field(default=-1)
     influence_regen: int = Field(default=-1)
+    action_cost: dict[str, int] = Field(default_factory=lambda: {"energy": 4})
 
-    # Movement cost
-    move_energy_cost: int = Field(default=3)
-
-    def agent_config(self, gear: list[str], elements: list[str]) -> AgentConfig:
+    def agent_config(self, team: str, max_steps: int) -> AgentConfig:
         """Create an AgentConfig for this cog configuration."""
         return AgentConfig(
-            collective="cogs",
+            collective=team,
             inventory=InventoryConfig(
                 limits={
                     "hp": ResourceLimitsConfig(min=self.hp_limit, resources=["hp"], modifiers=self.hp_modifiers),
                     # when hp == 0, the cog can't hold gear or hearts
-                    "gear": ResourceLimitsConfig(max=self.gear_limit, resources=gear, modifiers={"hp": 100}),
+                    "gear": ResourceLimitsConfig(max=self.gear_limit, resources=CvCConfig.GEAR, modifiers={"hp": 100}),
                     "heart": ResourceLimitsConfig(max=self.heart_limit, resources=["heart"], modifiers={"hp": 100}),
                     "energy": ResourceLimitsConfig(
                         min=self.energy_limit, resources=["energy"], modifiers=self.energy_modifiers
                     ),
                     "cargo": ResourceLimitsConfig(
-                        min=self.cargo_limit, resources=elements, modifiers=self.cargo_modifiers
+                        min=self.cargo_limit, resources=CvCConfig.ELEMENTS, modifiers=self.cargo_modifiers
                     ),
                     "influence": ResourceLimitsConfig(
                         min=self.influence_limit, resources=["influence"], modifiers=self.influence_modifiers
                     ),
                 },
-                initial={"energy": self.initial_energy, "hp": self.initial_hp},
+                initial={"energy": self.initial_energy, "hp": self.initial_hp, "solar": self.initial_solar},
             ),
             on_tick={
                 "regen": Handler(
                     mutations=[
                         updateActor(
                             {
-                                "energy": self.energy_regen,
                                 "hp": self.hp_regen,
                                 "influence": self.influence_regen,
                             }
                         )
                     ]
-                )
+                ),
+                "solar_to_energy": Handler(
+                    mutations=[
+                        SetGameValueMutation(
+                            value=InventoryValue(item="energy"),
+                            source=InventoryValue(item="solar"),
+                            target=EntityTarget.ACTOR,
+                        )
+                    ]
+                ),
+            },
+            rewards={
+                "aligned_junction_held": reward(
+                    game_stat("collective.aligned.junction.held"),
+                    weight=1.0 / max_steps,
+                ),
             },
         )

cogames/cogs_vs_clips/cogsguard_curriculum.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Sequence
+
+from cogames.cogs_vs_clips.mission import CvCMission
+from cogames.cogs_vs_clips.reward_variants import AVAILABLE_REWARD_VARIANTS
+from cogames.cogs_vs_clips.variants import HIDDEN_VARIANTS, VARIANTS
+from cogames.core import CoGameMissionVariant
+
+
+@dataclass(frozen=True)
+class EventProfile:
+    name: str
+    clips_overrides: dict[str, object]
+    weather_overrides: dict[str, object]
+
+
+COGSGUARD_FIXED_MAPS: list[str] = [
+    "machina_100_stations.map",
+    "machina_200_stations.map",
+    "cave_base_50.map",
+    "vanilla_large.map",
+]
+
+DEFAULT_EVENT_PROFILE = EventProfile("events_baseline", {}, {})
+COGSGUARD_EVENT_PROFILES: list[EventProfile] = [
+    DEFAULT_EVENT_PROFILE,
+    EventProfile(
+        "events_fast_clips_short_day",
+        {
+            "initial_clips_start": 5,
+            "initial_clips_spots": 2,
+            "scramble_start": 25,
+            "scramble_interval": 50,
+            "scramble_radius": 35,
+            "align_start": 50,
+            "align_interval": 50,
+            "align_radius": 35,
+        },
+        {"day_length": 100},
+    ),
+    EventProfile(
+        "events_slow_clips_long_day",
+        {
+            "initial_clips_start": 50,
+            "initial_clips_spots": 1,
+            "scramble_start": 200,
+            "scramble_interval": 200,
+            "scramble_radius": 15,
+            "align_start": 300,
+            "align_interval": 200,
+            "align_radius": 15,
+        },
+        {"day_length": 400},
+    ),
+    EventProfile(
+        "events_no_clips",
+        {"disabled": True},
+        {"day_length": 200},
+    ),
+]
+
+
+def normalize_variant_names(variants: str | Sequence[str] | None) -> list[str]:
+    if variants is None:
+        return []
+    if isinstance(variants, str):
+        if variants.startswith("["):
+            parsed = json.loads(variants)
+            if isinstance(parsed, list):
+                return [str(name) for name in parsed]
+        return [variants]
+    return list(variants)
+
+
+def split_variants(
+    variants: str | Sequence[str] | None,
+) -> tuple[list[CoGameMissionVariant], list[str]]:
+    if variants is None:
+        names: list[str] = []
+    else:
+        names = normalize_variant_names(variants)
+    all_variants = {variant.name: variant for variant in [*VARIANTS, *HIDDEN_VARIANTS]}
+    reward_variants = set(AVAILABLE_REWARD_VARIANTS)
+
+    resolved: list[CoGameMissionVariant] = []
+    resolved_rewards: list[str] = []
+    unknown: list[str] = []
+    for name in names:
+        if name in reward_variants:
+            resolved_rewards.append(name)
+            continue
+        variant = all_variants.get(name)
+        if variant is None:
+            unknown.append(name)
+            continue
+        resolved.append(variant)
+
+    if unknown:
+        available_mission = ", ".join(v.name for v in VARIANTS)
+        available_reward = ", ".join(AVAILABLE_REWARD_VARIANTS)
+        missing = ", ".join(unknown)
+        raise ValueError(
+            f"Unknown variant(s): {missing}. Mission variants: {available_mission}. "
+            f"Reward variants: {available_reward}."
+        )
+
+    return resolved, resolved_rewards
+
+
+def resolve_event_profiles(event_profiles: Sequence[EventProfile] | None) -> list[EventProfile]:
+    if event_profiles is None:
+        return [DEFAULT_EVENT_PROFILE]
+    return list(event_profiles)
+
+
+def filter_compatible_variants(
+    mission: CvCMission, variants: Sequence[CoGameMissionVariant]
+) -> list[CoGameMissionVariant]:
+    return [variant for variant in variants if variant.compat(mission)]

cogames/cogs_vs_clips/cogsguard_tutorial.py

@@ -1,12 +1,14 @@
 """CogsGuard tutorial mission configuration."""
 
-from cogames.cogs_vs_clips.mission import Mission, Site
-from cogames.cogs_vs_clips.procedural import MachinaArena
+from cogames.cogs_vs_clips.mission import CvCMission
+from cogames.cogs_vs_clips.team import CogTeam
+from cogames.cogs_vs_clips.terrain import MachinaArena
+from cogames.core import CoGameSite
 from mettagrid.mapgen.mapgen import MapGen
 from mettagrid.mapgen.scenes.base_hub import BaseHubConfig
 
 
-def make_cogsguard_tutorial_site() -> Site:
+def make_cogsguard_tutorial_site() -> CoGameSite:
     """Create a smaller, simpler CogsGuard arena for the tutorial."""
     hub_config = BaseHubConfig(
         corner_bundle="extractors",
@@ -16,11 +18,11 @@ def make_cogsguard_tutorial_site() -> Site:
         hub_height=15,
         outer_clearance=2,
         stations=[
-            "aligner_station",
-            "scrambler_station",
-            "miner_station",
-            "scout_station",
-            "chest",
+            "c:aligner",
+            "c:scrambler",
+            "c:miner",
+            "c:scout",
+            "c:chest",
         ],
     )
     map_builder = MapGen.Config(
@@ -32,7 +34,7 @@ def make_cogsguard_tutorial_site() -> Site:
             hub=hub_config,
         ),
     )
-    return Site(
+    return CoGameSite(
         name="cogsguard_tutorial",
         description="CogsGuard tutorial arena - small map for learning",
         map_builder=map_builder,
@@ -41,16 +43,13 @@ def make_cogsguard_tutorial_site() -> Site:
     )
 
 
-CogsGuardTutorialMission = Mission(
+CogsGuardTutorialMission = CvCMission(
     name="tutorial",
     description="Learn the basics of CogsGuard: Roles, Resources, and Territory Control.",
     site=make_cogsguard_tutorial_site(),
     num_cogs=1,
     max_steps=2000,
-    # Generous initial resources for learning
-    collective_initial_carbon=50,
-    collective_initial_oxygen=50,
-    collective_initial_germanium=50,
-    collective_initial_silicon=50,
-    collective_initial_heart=10,
+    teams={
+        "cogs": CogTeam(name="cogs", num_agents=1, wealth=1),
+    },
 )

cogames/cogs_vs_clips/config.py

@@ -0,0 +1,38 @@
+from types import SimpleNamespace
+
+from mettagrid.config.vibes import Vibe
+
+_GEAR = ["aligner", "scrambler", "miner", "scout"]
+_ELEMENTS = ["oxygen", "carbon", "germanium", "silicon"]
+_VIBES = [
+    Vibe("😐", "default"),
+    Vibe("❤️", "heart"),
+    Vibe("⚙️", "gear"),
+    Vibe("🌀", "scrambler"),
+    Vibe("🔗", "aligner"),
+    Vibe("⛏️", "miner"),
+    Vibe("🔭", "scout"),
+]
+
+CvCConfig = SimpleNamespace(
+    GEAR=_GEAR,
+    ELEMENTS=_ELEMENTS,
+    HEART_COST={e: 10 for e in _ELEMENTS},
+    ALIGN_COST={"heart": 1},
+    SCRAMBLE_COST={"heart": 1},
+    GEAR_COSTS={
+        "aligner": {"carbon": 3, "oxygen": 1, "germanium": 1, "silicon": 1},
+        "scrambler": {"carbon": 1, "oxygen": 3, "germanium": 1, "silicon": 1},
+        "miner": {"carbon": 1, "oxygen": 1, "germanium": 3, "silicon": 1},
+        "scout": {"carbon": 1, "oxygen": 1, "germanium": 1, "silicon": 3},
+    },
+    GEAR_SYMBOLS={
+        "aligner": "🔗",
+        "scrambler": "🌀",
+        "miner": "⛏️",
+        "scout": "🔭",
+    },
+    RESOURCES=["energy", "heart", "hp", "influence", "solar", *_ELEMENTS, *_GEAR],
+    VIBES=_VIBES,
+    VIBE_NAMES=[vibe.name for vibe in _VIBES],
+)

cogames/cogs_vs_clips/{cogs_vs_clips_mapgen.md → docs/cogs_vs_clips_mapgen.md}

@@ -324,7 +324,6 @@ Key design choices:
 
 - Pack the base hub lightly (`EmptyBaseVariant`) where appropriate to encourage early exploration without
   over-constraining.
-- Add guidance (`CompassVariant`) on distance-heavy tasks to reduce pure exploration failure modes.
 - Raise agent caps modestly (`PackRatVariant`) to avoid early inventory stalls but keep routing relevant.
 - Shape reward on vibe missions (`HeartChorusVariant`) so partial progress is scored.
 - Keep vibe mechanics intact unless the mission explicitly focuses on vibe manipulation.
@@ -334,21 +333,20 @@ Included missions and variants:
 - oxygen_bottleneck: `EmptyBaseVariant(missing=["oxygen_extractor"])`, `ResourceBottleneckVariant(["oxygen"])`,
   `SingleResourceUniformVariant("oxygen_extractor")`, `PackRatVariant`
 - energy_starved: `EmptyBaseVariant`, `DarkSideVariant`, `PackRatVariant`
-- distant_resources: `EmptyBaseVariant`, `CompassVariant`, `DistantResourcesVariant`
-- quadrant_buildings: `EmptyBaseVariant`, `QuadrantBuildingsVariant`, `CompassVariant`
-- single_use_swarm: `EmptyBaseVariant`, `SingleUseSwarmVariant`, `CompassVariant`, `PackRatVariant`
+- distant_resources: `EmptyBaseVariant`, `DistantResourcesVariant`
+- quadrant_buildings: `EmptyBaseVariant`, `QuadrantBuildingsVariant`
+- single_use_swarm: `EmptyBaseVariant`, `SingleUseSwarmVariant`, `PackRatVariant`
 - vibe_check: `HeartChorusVariant`, `VibeCheckMin2Variant`
 
 Usage example:
 
 ```bash
-uv run python packages/cogames/scripts/run_evaluation.py \
-  --policy thinky \
+uv run cogames diagnose thinky \
   --mission-set integrated_evals \
   --cogs 4 \
-  --repeats 2
+  --episodes 2
 ```
 
-Recommendation: When designing new scorable baselines, combine one “shaping” variant (e.g., `CompassVariant`,
-`HeartChorusVariant`, `PackRatVariant`) with one “constraint” variant (e.g., `DarkSideVariant`,
-`ResourceBottleneckVariant`, `SingleUseSwarmVariant`) to keep tasks legible yet challenging.
+Recommendation: When designing new scorable baselines, combine one "shaping" variant (e.g., `HeartChorusVariant`,
+`PackRatVariant`) with one "constraint" variant (e.g., `DarkSideVariant`, `ResourceBottleneckVariant`,
+`SingleUseSwarmVariant`) to keep tasks legible yet challenging.

cogames/cogs_vs_clips/evals/README.md

@@ -179,11 +179,11 @@ uv run cogames play --mission hello_world.easy_hearts --cogs 2
 You can apply additional variants on top of the mission's built-in variants:
 
 ```bash
-# Add compass variant
-uv run cogames play --mission hello_world.oxygen_bottleneck --cogs 2 --variant compass
+# Add pack_rat variant
+uv run cogames play --mission hello_world.oxygen_bottleneck --cogs 2 --variant pack_rat
 
 # Add multiple variants
-uv run cogames play --mission hello_world.energy_starved --cogs 2 --variant compass --variant small_50
+uv run cogames play --mission hello_world.energy_starved --cogs 2 --variant pack_rat --variant small_50
 
 # With policy
 uv run cogames play --mission hello_world.single_use_swarm --cogs 4 -p baseline
@@ -193,49 +193,25 @@ uv run cogames play --mission hello_world.single_use_swarm --cogs 4 -p baseline
 
 ## Programmatic Evaluation
 
-### Using run_evaluation.py
+### Using cogames diagnose / cogames run
 
 For systematic evaluation across multiple missions and configurations:
 
 ```bash
 # Evaluate on integrated eval suite
-uv run python packages/cogames/scripts/run_evaluation.py \
-  --policy thinky \
+uv run cogames diagnose thinky \
   --mission-set integrated_evals \
   --cogs 4 \
-  --repeats 2
+  --episodes 2
 
-# Evaluate specific agent
-uv run python packages/cogames/scripts/run_evaluation.py \
+# Evaluate specific agent with structured output
+uv run cogames run \
+  --mission-set integrated_evals \
   --policy baseline \
-  --steps 1000 \
-  --output eval_baseline.json
+  --episodes 10 \
+  --format json
 ```
 
-### Using in Curriculum Training
-
-Both diagnostic and integrated missions can be used in curriculum training via `mission_variant_curriculum.py`:
-
-```python
-from recipes.experiment.cvc import mission_variant_curriculum
-
-# Train on diagnostic missions
-mission_variant_curriculum.train(
-    base_missions=["diagnostic_missions"],
-    num_cogs=4,
-    variants="all"
-)
-
-# Train on specific integrated missions
-mission_variant_curriculum.train(
-    base_missions=["oxygen_bottleneck", "energy_starved"],
-    num_cogs=4,
-    variants=["compass", "pack_rat"]
-)
-```
-
----
-
 ## Design Philosophy
 
 ### Diagnostic Missions

cogames/cogs_vs_clips/evals/cogsguard_evals.py

@@ -2,15 +2,30 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from cogames.cogs_vs_clips.mission import CogsGuardMission, Site
-from cogames.cogs_vs_clips.mission_utils import get_map
+from cogames.cogs_vs_clips.mission import CvCMission
+from cogames.core import CoGameSite as Site
+from mettagrid.map_builder.map_builder import MapBuilderConfig
+from mettagrid.mapgen.mapgen import MapGen, MapGenConfig
 
 MAPS_DIR = Path(__file__).resolve().parent.parent.parent / "maps"
 
+
+def _load_map(map_name: str) -> MapGenConfig:
+    map_path = MAPS_DIR / map_name
+    if not map_path.exists():
+        raise FileNotFoundError(f"Map not found: {map_path}")
+    return MapGen.Config(
+        instance=MapBuilderConfig.from_uri(str(map_path)),
+        instances=1,
+        fixed_spawn_order=False,
+        instance_border_width=0,
+    )
+
+
 COGSGUARD_EVALS_BASE = Site(
     name="cogsguard_evals",
     description="CogsGuard evaluation arenas.",
-    map_builder=get_map("evals/eval_balanced_spread.map"),
+    map_builder=_load_map("evals/eval_balanced_spread.map"),
     min_cogs=1,
     max_cogs=20,
 )
@@ -30,7 +45,7 @@ def _count_spawn_pads(map_path: Path) -> int:
 def _make_eval_site(map_name: str, num_cogs: int) -> Site:
     site = COGSGUARD_EVALS_BASE.model_copy(
         update={
-            "map_builder": get_map(map_name),
+            "map_builder": _load_map(map_name),
             "min_cogs": num_cogs,
             "max_cogs": num_cogs,
         }
@@ -66,13 +81,13 @@ COGSGUARD_EVAL_MAPS: list[str] = [
 
 COGSGUARD_EVAL_COGS = {map_name: _count_spawn_pads(MAPS_DIR / map_name) for map_name in COGSGUARD_EVAL_MAPS}
 
-COGSGUARD_EVAL_MISSIONS: list[CogsGuardMission] = []
+COGSGUARD_EVAL_MISSIONS: list[CvCMission] = []
 for map_name in COGSGUARD_EVAL_MAPS:
     stem = Path(map_name).stem
     num_cogs = COGSGUARD_EVAL_COGS[map_name]
     site = _make_eval_site(map_name, num_cogs)
     COGSGUARD_EVAL_MISSIONS.append(
-        CogsGuardMission(
+        CvCMission(
             name=stem,
             description=_description_from_stem(stem),
             site=site,

cogames/cogs_vs_clips/evals/diagnostic_evals.py

@@ -1,54 +1,21 @@
 from __future__ import annotations
 
-from pathlib import Path
 from typing import Dict
 
 from pydantic import Field
 
 from cogames.cogs_vs_clips.cog import CogConfig
-from cogames.cogs_vs_clips.mission import Mission, Site
-from mettagrid.config.game_value import stat
+from cogames.cogs_vs_clips.mission import CvCMission
+from cogames.cogs_vs_clips.sites import EVALS, get_map
+from cogames.core import CoGameSite
 from mettagrid.config.handler_config import Handler
 from mettagrid.config.mettagrid_config import (
-    ChestConfig,
     MettaGridConfig,
-    ResourceLimitsConfig,
 )
 from mettagrid.config.mutation.resource_mutation import updateActor
-from mettagrid.config.reward_config import reward
-from mettagrid.map_builder.map_builder import MapBuilderConfig
-from mettagrid.mapgen.mapgen import MapGen
 
 RESOURCE_NAMES: tuple[str, ...] = ("carbon", "oxygen", "germanium", "silicon")
 
-MAPS_DIR = Path(__file__).resolve().parent.parent.parent / "maps"
-
-
-def get_map(map_name: str) -> MapBuilderConfig:
-    """Load a map builder configuration from the local diagnostics directory."""
-    normalized = map_name
-    if normalized.startswith("evals/"):
-        normalized = f"diagnostic_evals/{normalized.split('/', 1)[1]}"
-    map_path = MAPS_DIR / normalized
-    if not map_path.exists():
-        raise FileNotFoundError(f"Diagnostic map not found: {map_path}")
-    # Wrap AsciiMapBuilderConfig in MapGen.Config to match standard get_map() behavior
-    return MapGen.Config(
-        instance=MapBuilderConfig.from_uri(str(map_path)),
-        instances=1,  # Force single instance - use spawn points from ASCII map directly
-        fixed_spawn_order=False,
-        instance_border_width=0,  # Don't add border - maps already have borders built in
-    )
-
-
-EVALS = Site(
-    name="evals",
-    description="Diagnostic evaluation arenas.",
-    map_builder=get_map("evals/diagnostic_radial.map"),
-    min_cogs=1,
-    max_cogs=4,
-)
-
 
 # Generous cog config for diagnostic missions: high limits and full energy regen
 _GENEROUS_COG = CogConfig(
@@ -59,30 +26,15 @@ _GENEROUS_COG = CogConfig(
     cargo_limit=255,
     initial_energy=255,
     initial_hp=100,
-    energy_regen=255,
-    hp_regen=0,
-    influence_regen=0,
-)
-
-# Same but without generous energy regen (for charge-up diagnostics)
-_MODEST_COG = CogConfig(
-    gear_limit=255,
-    hp_limit=255,
-    heart_limit=255,
-    energy_limit=255,
-    cargo_limit=255,
-    initial_energy=255,
-    initial_hp=100,
-    energy_regen=1,
     hp_regen=0,
     influence_regen=0,
 )
 
 
-class _DiagnosticMissionBase(Mission):
+class _DiagnosticMissionBase(CvCMission):
     """Base class for minimal diagnostic evaluation missions."""
 
-    site: Site = EVALS
+    site: CoGameSite = EVALS
     cog: CogConfig = Field(default_factory=lambda: _GENEROUS_COG.model_copy())
 
     map_name: str = Field(default="evals/diagnostic_eval_template.map")
@@ -90,15 +42,9 @@ class _DiagnosticMissionBase(Mission):
     required_agents: int | None = Field(default=None)
 
     inventory_seed: Dict[str, int] = Field(default_factory=dict)
-    communal_chest_hearts: int | None = Field(default=None)
-    resource_chest_stock: Dict[str, int] = Field(default_factory=dict)
     # If True, give agents high energy capacity and regen (overridden by specific missions)
     generous_energy: bool = Field(default=True)
 
-    # Disable clips events for diagnostic evals
-    clips_scramble_start: int = Field(default=99999)
-    clips_align_start: int = Field(default=99999)
-
     def configure_env(self, cfg: MettaGridConfig) -> None:  # pragma: no cover - hook for subclasses
         """Hook for mission-specific environment alterations."""
 
@@ -114,10 +60,6 @@ class _DiagnosticMissionBase(Mission):
             cfg.game.map_builder = forced_map
             cfg.game.max_steps = self.max_steps
             self._apply_inventory_seed(cfg)
-            self._apply_communal_chest(cfg)
-            self._apply_resource_chests(cfg)
-            # Finally, normalize rewards so a single deposited heart yields at most 1 reward.
-            self._apply_heart_reward_cap(cfg)
             self.configure_env(cfg)
             return cfg
         finally:
@@ -134,45 +76,15 @@ class _DiagnosticMissionBase(Mission):
         seed = dict(cfg.game.agent.inventory.initial)
         seed.update(self.inventory_seed)
         cfg.game.agent.inventory.initial = seed
-
-    def _apply_communal_chest(self, cfg: MettaGridConfig) -> None:
-        if self.communal_chest_hearts is None:
-            return
-        chest = cfg.game.objects.get("communal_chest")
-        if isinstance(chest, ChestConfig):
-            chest.inventory.initial = {"heart": self.communal_chest_hearts}
-
-    def _apply_resource_chests(self, cfg: MettaGridConfig) -> None:
-        if not self.resource_chest_stock:
-            return
-        for resource, amount in self.resource_chest_stock.items():
-            chest_cfg = cfg.game.objects.get(f"chest_{resource}")
-            if isinstance(chest_cfg, ChestConfig):
-                chest_cfg.inventory.initial = {resource: amount}
-
-    def _apply_heart_reward_cap(self, cfg: MettaGridConfig) -> None:
-        """Normalize diagnostics so a single deposited heart yields at most 1 reward per episode.
-
-        - Make each agent-deposited heart worth exactly 1.0 reward (credited only to the depositor).
-        - Ensure all chests can store at most 1 heart so total reward per episode cannot exceed 1.
-        """
-        agent_cfg = cfg.game.agent
-        rewards = dict(agent_cfg.rewards)
-        rewards["chest_heart_deposited_by_agent"] = reward(stat("chest.heart.deposited_by_agent"))
-        agent_cfg.rewards = rewards
-
-        # Cap heart capacity for every chest used in diagnostics (communal or resource-specific).
-        for _name, obj in cfg.game.objects.items():
-            if not isinstance(obj, ChestConfig):
-                continue
-            # Find existing heart limit or create new one
-            heart_limit = obj.inventory.limits.get("heart", ResourceLimitsConfig(min=1, resources=["heart"]))
-            heart_limit.min = 1
-            obj.inventory.limits["heart"] = heart_limit
+        # Also apply to per-agent configs (used by CvCMission)
+        for agent_cfg in cfg.game.agents:
+            agent_seed = dict(agent_cfg.inventory.initial)
+            agent_seed.update(self.inventory_seed)
+            agent_cfg.inventory.initial = agent_seed
 
 
 # ----------------------------------------------------------------------
-# Diagnostics (non-hub)
+# Diagnostic missions (no assemblers)
 # ----------------------------------------------------------------------
 
 
@@ -234,7 +146,7 @@ class DiagnosticChargeUp(_DiagnosticMissionBase):
     max_steps: int = Field(default=250)
 
     def configure_env(self, cfg: MettaGridConfig) -> None:
-        # Set starting energy to 30 and no regen
+        # Set starting energy to 60 and no regen
         agent = cfg.game.agent
         agent.inventory.initial = dict(agent.inventory.initial)
         agent.inventory.initial["energy"] = 60
@@ -302,7 +214,7 @@ class DiagnosticChargeUpHard(_DiagnosticMissionBase):
     max_steps: int = Field(default=350)
 
     def configure_env(self, cfg: MettaGridConfig) -> None:
-        # Set starting energy to 30 and no regen
+        # Set starting energy to 60 and no regen
         agent = cfg.game.agent
         agent.inventory.initial = dict(agent.inventory.initial)
         agent.inventory.initial["energy"] = 60