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

cogames/cli/submit.py

@@ -10,22 +10,21 @@ import uuid
 import zipfile
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING
 
 import httpx
 import typer
 from rich.console import Console
 
 from cogames.cli.base import console
+from cogames.cli.client import TournamentServerClient
 from cogames.cli.login import DEFAULT_COGAMES_SERVER
-from cogames.cli.policy import PolicySpec, get_policy_spec
-from metta_alo.rollout import run_single_episode
-
-if TYPE_CHECKING:
-    from cogames.cli.client import TournamentServerClient
-
+from cogames.cli.mission import get_mission
+from cogames.cli.policy import PolicySpec, get_policy_spec, parse_policy_spec
 from mettagrid.config.mettagrid_config import MettaGridConfig
+from mettagrid.policy.prepare_policy_spec import download_policy_spec_from_s3_as_zip
 from mettagrid.policy.submission import POLICY_SPEC_FILENAME, SubmissionPolicySpec
+from mettagrid.runner.rollout import run_episode_local
+from mettagrid.util.uri_resolvers.schemes import parse_uri, resolve_uri
 
 DEFAULT_SUBMIT_SERVER = "https://api.observatory.softmax-research.net"
 
@@ -51,12 +50,11 @@ def validate_paths(paths: list[str], console: Console) -> list[Path]:
         raw_path = Path(path_str).expanduser()
 
         # Resolve the path and check it's within CWD
-        try:
-            resolved = raw_path.resolve() if raw_path.is_absolute() else (cwd / raw_path).resolve()
-            relative = resolved.relative_to(cwd)
-        except ValueError:
+        resolved = raw_path.resolve() if raw_path.is_absolute() else (cwd / raw_path).resolve()
+        if not resolved.is_relative_to(cwd):
             console.print(f"[red]Error:[/red] Path must be within the current directory: {path_str}")
-            raise ValueError(f"Path escapes CWD: {path_str}") from None
+            raise ValueError(f"Path escapes CWD: {path_str}")
+        relative = resolved.relative_to(cwd)
 
         # Check if path exists
         if not resolved.exists():
@@ -70,9 +68,6 @@ def validate_paths(paths: list[str], console: Console) -> list[Path]:
 
 def _maybe_resolve_checkpoint_bundle_uri(policy: str) -> tuple[Path, bool] | None:
     """Return (local_zip_path, cleanup) if policy points to a checkpoint bundle URI."""
-    from mettagrid.policy.prepare_policy_spec import download_policy_spec_from_s3_as_zip
-    from mettagrid.util.uri_resolvers.schemes import parse_uri, resolve_uri
-
     first = policy.split(",", 1)[0].strip()
     parsed = parse_uri(first, allow_none=True, default_scheme=None)
     if parsed is None or parsed.scheme not in {"file", "s3"}:
@@ -111,9 +106,8 @@ def _zip_directory_bundle(bundle_dir: Path) -> Path:
 def validate_bundle_in_isolation(policy_zip: Path, console: Console, *, season: str, server: str) -> bool:
     console.print("[dim]Testing policy bundle can run 10 steps...[/dim]")
 
-    temp_dir = None
+    temp_dir = create_temp_validation_env()
     try:
-        temp_dir = create_temp_validation_env()
         bundle_name = policy_zip.name
         shutil.copy2(policy_zip, temp_dir / bundle_name)
 
@@ -148,11 +142,8 @@ def validate_bundle_in_isolation(policy_zip: Path, console: Console, *, season:
 
         console.print("[green]Validation passed[/green]")
         return True
-    except subprocess.TimeoutExpired:
-        console.print("[red]Validation timed out after 5 minutes[/red]")
-        return False
     finally:
-        if temp_dir and temp_dir.exists():
+        if temp_dir.exists():
             shutil.rmtree(temp_dir)
 
 
@@ -214,8 +205,46 @@ def copy_files_maintaining_structure(files: list[Path], dest_dir: Path) -> None:
             shutil.copy2(file_path, dest_path)
 
 
-def validate_policy_spec(policy_spec: PolicySpec, env_cfg: MettaGridConfig) -> None:
-    env_cfg = env_cfg.model_copy()
+_SEASON_VALIDATION_MISSIONS: dict[str, str] = {
+    "beta": "training_facility.harvest",
+    "beta-cogsguard": "cogsguard_arena.basic",
+}
+_DEFAULT_VALIDATION_MISSION = "cogsguard_arena.basic"
+
+
+def get_validation_mission_for_season(season: str | None = None) -> str:
+    """Get the appropriate mission for validating policies in a given season."""
+    if season is None:
+        return _DEFAULT_VALIDATION_MISSION
+    return _SEASON_VALIDATION_MISSIONS.get(season, _DEFAULT_VALIDATION_MISSION)
+
+
+def validate_policy_spec(
+    policy_spec: PolicySpec,
+    env_cfg: MettaGridConfig | None = None,
+    *,
+    device: str = "cpu",
+    season: str | None = None,
+) -> None:
+    """Validate policy works.
+
+    Runs a single episode (up to 10 steps) using the same alo rollout flow as `cogames eval`.
+
+    Args:
+        policy_spec: The policy to validate.
+        env_cfg: Optional environment config to validate against.
+        device: Target device for policy evaluation (cpu/cuda/auto).
+        season: Optional season name to determine which game to validate against.
+    """
+    if env_cfg is None:
+        mission_name = get_validation_mission_for_season(season)
+        # Legacy seasons (e.g., "beta") use legacy missions that require include_legacy=True
+        include_legacy = season in _SEASON_VALIDATION_MISSIONS
+        _, env_cfg, _ = get_mission(mission_name, include_legacy=include_legacy)
+    else:
+        env_cfg = env_cfg.model_copy()
+
+    # Run 1 episode for up to 10 steps to validate the policy works
     env_cfg.game.max_steps = 10
     n = env_cfg.game.num_agents
     n_submitted = min(2, n)
@@ -226,18 +255,21 @@ def validate_policy_spec(policy_spec: PolicySpec, env_cfg: MettaGridConfig) -> N
     else:
         policy_specs = [policy_spec]
         assignments = [0] * n
-    run_single_episode(
+    run_episode_local(
         policy_specs=policy_specs,
         assignments=assignments,
         env=env_cfg,
-        results_uri=None,
-        replay_uri=None,
         seed=42,
         max_action_time_ms=10000,
-        device="cpu",
+        device=device,
     )
 
 
+def validate_policy_uri(policy_uri: str, env_cfg: MettaGridConfig, *, device: str = "cpu") -> None:
+    policy_spec = parse_policy_spec(policy_uri, device=device).to_policy_spec()
+    validate_policy_spec(policy_spec, env_cfg, device=device)
+
+
 def validate_policy_in_isolation(
     policy_spec: PolicySpec,
     include_files: list[Path],
@@ -257,9 +289,8 @@ def validate_policy_in_isolation(
 
     console.print("[dim]Testing policy can run 10 steps...[/dim]")
 
-    temp_dir = None
+    temp_dir = create_temp_validation_env()
     try:
-        temp_dir = create_temp_validation_env()
         copy_files_maintaining_structure(include_files, temp_dir)
 
         policy_arg = _format_policy_arg(policy_spec)
@@ -304,17 +335,23 @@ def validate_policy_in_isolation(
 
         console.print("[green]Validation passed[/green]")
         return True
-
-    except subprocess.TimeoutExpired:
-        console.print("[red]Validation timed out after 5 minutes[/red]")
-        return False
-    except Exception:
-        return False
     finally:
-        if temp_dir and temp_dir.exists():
+        if temp_dir.exists():
             shutil.rmtree(temp_dir)
 
 
+def _collect_ancestor_init_files(include_files: list[Path]) -> list[Path]:
+    found: set[Path] = set()
+    for path in include_files:
+        parent = path.parent
+        while parent != Path(".") and parent != parent.parent:
+            init = parent / "__init__.py"
+            if init.is_file():
+                found.add(init)
+            parent = parent.parent
+    return sorted(found)
+
+
 def create_submission_zip(
     include_files: list[Path],
     policy_spec: PolicySpec,
@@ -335,17 +372,22 @@ def create_submission_zip(
         setup_script=setup_script,
     )
 
+    all_files: dict[str, Path] = {}
+    for init_path in _collect_ancestor_init_files(include_files):
+        all_files[str(init_path)] = init_path
+    for file_path in include_files:
+        if file_path.is_dir():
+            for root, _, files in os.walk(file_path):
+                for file in files:
+                    full = Path(root) / file
+                    all_files[str(full)] = full
+        else:
+            all_files[str(file_path)] = file_path
+
     with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
         zipf.writestr(data=submission_spec.model_dump_json(), zinfo_or_arcname=POLICY_SPEC_FILENAME)
-
-        for file_path in include_files:
-            if file_path.is_dir():
-                for root, _, files in os.walk(file_path):
-                    for file in files:
-                        file_full_path = Path(root) / file
-                        zipf.write(file_full_path, arcname=file_full_path)
-            else:
-                zipf.write(file_path, arcname=file_path)
+        for arcname, path in all_files.items():
+            zipf.write(path, arcname=arcname)
 
     return Path(zip_path)
 
@@ -360,82 +402,45 @@ def upload_submission(
     """Upload submission to CoGames backend using a presigned S3 URL."""
     console.print("[bold]Uploading[/bold]")
 
-    try:
-        presigned_data = client.get_presigned_upload_url()
-        upload_url = presigned_data.get("upload_url")
-        upload_id = presigned_data.get("upload_id")
+    presigned_data = client.get_presigned_upload_url()
+    upload_url = presigned_data.get("upload_url")
+    upload_id = presigned_data.get("upload_id")
 
-        if not upload_url or not upload_id:
-            console.print("[red]Upload URL missing from response[/red]")
-            return None
-    except httpx.TimeoutException:
-        console.print("[red]Timed out while requesting upload URL[/red]")
-        return None
-    except httpx.HTTPStatusError as exc:
-        console.print(f"[red]Failed to get upload URL ({exc.response.status_code})[/red]")
-        console.print(f"[dim]{exc.response.text}[/dim]")
-        return None
-    except Exception as e:
-        console.print(f"[red]Error requesting upload URL: {e}[/red]")
-        return None
+    if not upload_url or not upload_id:
+        raise ValueError("Upload URL missing from response")
 
     console.print("[dim]Uploading to storage...[/dim]")
 
-    try:
-        with open(zip_path, "rb") as f:
-            upload_response = httpx.put(
-                upload_url,
-                content=f,
-                headers={"Content-Type": "application/zip"},
-                timeout=600.0,
-            )
-        upload_response.raise_for_status()
-    except httpx.TimeoutException:
-        console.print("[red]Upload timed out after 10 minutes[/red]")
-        return None
-    except httpx.HTTPStatusError as exc:
-        console.print(f"[red]Upload failed with status {exc.response.status_code}[/red]")
-        console.print(f"[dim]{exc.response.text}[/dim]")
-        return None
-    except Exception as e:
-        console.print(f"[red]Upload error: {e}[/red]")
-        return None
+    with open(zip_path, "rb") as f:
+        upload_response = httpx.put(
+            upload_url,
+            content=f,
+            headers={"Content-Type": "application/zip"},
+            timeout=600.0,
+        )
+    upload_response.raise_for_status()
 
     if not season:
         console.print("[dim]Uploading policy...[/dim]")
     else:
         console.print(f"[dim]Uploading policy and submitting to season {season}...[/dim]")
 
+    result = client.complete_policy_upload(upload_id, submission_name, season=season)
+    submission_id = result.get("id")
+    name = result.get("name")
+    version = result.get("version")
+    pools = result.get("pools")
+    if submission_id is None or name is None or version is None:
+        raise ValueError("Missing fields in response")
     try:
-        result = client.complete_policy_upload(upload_id, submission_name, season=season)
-        submission_id = result.get("id")
-        name = result.get("name")
-        version = result.get("version")
-        pools = result.get("pools")
-        if submission_id is not None and name is not None and version is not None:
-            try:
-                return UploadResult(
-                    policy_version_id=uuid.UUID(str(submission_id)),
-                    name=name,
-                    version=version,
-                    pools=pools,
-                )
-            except ValueError:
-                console.print(f"[red]Invalid submission ID returned: {submission_id}[/red]")
-                return None
-
-        console.print("[red]Missing fields in response[/red]")
-        return None
-    except httpx.TimeoutException:
-        console.print("[red]Registration timed out[/red]")
-        return None
-    except httpx.HTTPStatusError as exc:
-        console.print(f"[red]Registration failed with status {exc.response.status_code}[/red]")
-        console.print(f"[dim]{exc.response.text}[/dim]")
-        return None
-    except Exception as e:
-        console.print(f"[red]Registration error: {e}[/red]")
-        return None
+        return UploadResult(
+            policy_version_id=uuid.UUID(str(submission_id)),
+            name=name,
+            version=version,
+            pools=pools,
+        )
+    except ValueError as exc:
+        raise ValueError(f"Invalid submission ID returned: {submission_id}") from exc
 
 
 def _upload_policy_bundle(
@@ -501,8 +506,6 @@ def upload_policy(
     validation_season: str = "",
     season: str | None = None,
 ) -> UploadResult | None:
-    from cogames.cli.client import TournamentServerClient
-
     if dry_run:
         console.print("[dim]Dry run mode - no upload[/dim]\n")
 
@@ -510,11 +513,7 @@ def upload_policy(
     if not client:
         return None
 
-    try:
-        bundle_result = _maybe_resolve_checkpoint_bundle_uri(policy)
-    except Exception as e:
-        console.print(f"[red]Error resolving checkpoint bundle:[/red] {e}")
-        return None
+    bundle_result = _maybe_resolve_checkpoint_bundle_uri(policy)
 
     if bundle_result is not None:
         return _upload_policy_bundle(
@@ -532,11 +531,7 @@ def upload_policy(
             season=season,
         )
 
-    try:
-        policy_spec = get_policy_spec(ctx, policy)
-    except Exception as e:
-        console.print(f"[red]Error parsing policy:[/red] {e}")
-        return None
+    policy_spec = get_policy_spec(ctx, policy)
 
     if init_kwargs:
         merged_kwargs = {**policy_spec.init_kwargs, **init_kwargs}
@@ -548,13 +543,12 @@ def upload_policy(
 
     cwd = Path.cwd().resolve()
     if policy_spec.data_path:
-        try:
-            resolved = Path(policy_spec.data_path).expanduser().resolve()
-            data_rel = str(resolved.relative_to(cwd))
-        except ValueError:
+        resolved = Path(policy_spec.data_path).expanduser().resolve()
+        if not resolved.is_relative_to(cwd):
             console.print("[red]Error:[/red] Policy weights path must be within the current directory.")
             console.print(f"[dim]{policy_spec.data_path}[/dim]")
-            return None
+            raise ValueError("Policy weights path must be within the current directory.")
+        data_rel = str(resolved.relative_to(cwd))
         policy_spec = PolicySpec(
             class_path=policy_spec.class_path,
             data_path=data_rel,
@@ -563,13 +557,12 @@ def upload_policy(
 
     setup_script_rel: str | None = None
     if setup_script:
-        try:
-            resolved = Path(setup_script).expanduser().resolve()
-            setup_script_rel = str(resolved.relative_to(cwd))
-        except ValueError:
+        resolved = Path(setup_script).expanduser().resolve()
+        if not resolved.is_relative_to(cwd):
             console.print("[red]Error:[/red] Setup script path must be within the current directory.")
             console.print(f"[dim]{setup_script}[/dim]")
-            return None
+            raise ValueError("Setup script path must be within the current directory.")
+        setup_script_rel = str(resolved.relative_to(cwd))
 
     files_to_include = []
     if policy_spec.data_path:
@@ -581,10 +574,7 @@ def upload_policy(
 
     validated_paths: list[Path] = []
     if files_to_include:
-        try:
-            validated_paths = validate_paths(files_to_include, console)
-        except (ValueError, FileNotFoundError):
-            return None
+        validated_paths = validate_paths(files_to_include, console)
 
     if not skip_validation:
         if not validate_policy_in_isolation(
@@ -600,11 +590,7 @@ def upload_policy(
     else:
         console.print("[dim]Skipping validation[/dim]")
 
-    try:
-        zip_path = create_submission_zip(validated_paths, policy_spec, setup_script=setup_script_rel)
-    except Exception as e:
-        console.print(f"[red]Error creating zip:[/red] {e}")
-        return None
+    zip_path = create_submission_zip(validated_paths, policy_spec, setup_script=setup_script_rel)
 
     if dry_run:
         console.print("[green]Dry run complete[/green]")

cogames/cli/utils.py

@@ -11,6 +11,11 @@ def suppress_noisy_logs() -> None:
     warnings.filterwarnings("ignore", category=DeprecationWarning, module="pkg_resources")
     warnings.filterwarnings("ignore", category=DeprecationWarning, module="pygame.pkgdata")
 
+    # Pyro docstrings use LaTeX math notation (\ge for ≥) which Python 3.12+ warns about:
+    # pyro/ops/stats.py:527: SyntaxWarning: invalid escape sequence '\g'
+    # Note: module= filter doesn't work for SyntaxWarnings (emitted at parse time before module loads)
+    warnings.filterwarnings("ignore", category=SyntaxWarning, message=r".*invalid escape sequence.*")
+
     # Silence PyTorch distributed elastic warning about redirects on MacOS/Windows
     logging.getLogger("torch.distributed.elastic.multiprocessing.redirects").setLevel(logging.ERROR)
     warnings.filterwarnings(

cogames/cogs_vs_clips/clip_difficulty.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Final, Optional
+
+from cogames.cogs_vs_clips.mission import CvCMission
+from cogames.core import CoGameMissionVariant
+
+MEDIUM_CLIPS_END: Final[int] = 300
+
+
+class CogsGuardDifficulty(CoGameMissionVariant):
+    name: str
+    description: str = ""
+    disable_clips: bool = False
+    scramble_end: Optional[int] = None
+    align_end: Optional[int] = None
+    presence_end: Optional[int] = None
+
+    def modify_mission(self, mission: CvCMission) -> None:
+        if self.disable_clips:
+            mission.clips.disabled = True
+            return
+
+        mission.clips.disabled = False
+        mission.clips.scramble_end = self.scramble_end
+        mission.clips.align_end = self.align_end
+        mission.clips.presence_end = self.presence_end
+
+
+EASY = CogsGuardDifficulty(
+    name="easy",
+    description="No clips events.",
+    disable_clips=True,
+)
+
+MEDIUM = CogsGuardDifficulty(
+    name="medium",
+    description="A few early clips events, then none.",
+    scramble_end=MEDIUM_CLIPS_END,
+    align_end=MEDIUM_CLIPS_END,
+    presence_end=MEDIUM_CLIPS_END,
+)
+
+HARD = CogsGuardDifficulty(
+    name="hard",
+    description="Standard clips event system.",
+)
+
+COGSGUARD_DIFFICULTIES: tuple[CogsGuardDifficulty, ...] = (EASY, MEDIUM, HARD)
+
+
+def get_cogsguard_difficulty(name: str) -> CogsGuardDifficulty:
+    for difficulty in COGSGUARD_DIFFICULTIES:
+        if difficulty.name == name:
+            return difficulty
+    available = ", ".join(d.name for d in COGSGUARD_DIFFICULTIES)
+    raise ValueError(f"Unknown difficulty '{name}'. Available difficulties: {available}")

cogames/cogs_vs_clips/clips.py

@@ -4,6 +4,8 @@ Clips are a non-player faction that gradually takes over neutral junctions.
 These events create the spreading/scrambling behavior that pressures players.
 """
 
+from typing import Optional
+
 from pydantic import Field
 
 from mettagrid.base_config import Config
@@ -18,6 +20,8 @@ from mettagrid.config.tag import typeTag
 class ClipsConfig(Config):
     """Configuration for clips behavior in CogsGuard game mode."""
 
+    disabled: bool = Field(default=False)
+
     # Clips Behavior - scramble cogs junctions to neutral
     initial_clips_start: int = Field(default=10)
     initial_clips_spots: int = Field(default=1)
@@ -25,11 +29,16 @@ class ClipsConfig(Config):
     scramble_start: int = Field(default=50)
     scramble_interval: int = Field(default=100)
     scramble_radius: int = Field(default=25)
+    scramble_end: Optional[int] = Field(default=None)
 
     # Clips Behavior - align neutral junctions to clips
     align_start: int = Field(default=100)
     align_interval: int = Field(default=100)
     align_radius: int = Field(default=25)
+    align_end: Optional[int] = Field(default=None)
+
+    # Clips Behavior - presence check for re-invasion
+    presence_end: Optional[int] = Field(default=None)
 
     def events(self, max_steps: int) -> dict[str, EventConfig]:
         """Create all clips events for a mission.
@@ -37,6 +46,12 @@ class ClipsConfig(Config):
         Returns:
             Dictionary of event name to EventConfig.
         """
+        if self.disabled:
+            return {}
+        scramble_end = max_steps if self.scramble_end is None else min(self.scramble_end, max_steps)
+        align_end = max_steps if self.align_end is None else min(self.align_end, max_steps)
+        presence_end = max_steps if self.presence_end is None else min(self.presence_end, max_steps)
+
         return {
             "initial_clips": EventConfig(
                 name="initial_clips",
@@ -48,7 +63,7 @@ class ClipsConfig(Config):
             "cogs_to_neutral": EventConfig(
                 name="cogs_to_neutral",
                 target_tag=typeTag("junction"),
-                timesteps=periodic(start=self.scramble_start, period=self.scramble_interval, end=max_steps),
+                timesteps=periodic(start=self.scramble_start, period=self.scramble_interval, end=scramble_end),
                 # near a clips-aligned junction
                 filters=[
                     isNear(typeTag("junction"), [isAlignedTo("clips")], radius=self.scramble_radius),
@@ -61,7 +76,7 @@ class ClipsConfig(Config):
             "neutral_to_clips": EventConfig(
                 name="neutral_to_clips",
                 target_tag=typeTag("junction"),
-                timesteps=periodic(start=self.align_start, period=self.align_interval, end=max_steps),
+                timesteps=periodic(start=self.align_start, period=self.align_interval, end=align_end),
                 # neutral junctions near a clips-aligned junction
                 filters=[
                     isNear(typeTag("junction"), [isAlignedTo("clips")], radius=self.align_radius),
@@ -74,13 +89,15 @@ class ClipsConfig(Config):
             "presence_check": EventConfig(
                 name="presence_check",
                 target_tag=typeTag("junction"),
-                timesteps=periodic(start=self.initial_clips_start, period=self.scramble_interval * 2, end=max_steps),
+                timesteps=periodic(start=self.initial_clips_start, period=self.scramble_interval * 2, end=presence_end),
                 filters=[isNear(typeTag("junction"), [isAlignedTo("clips")], radius=1000)],
                 max_targets=1,
                 fallback="initial_clips",
             ),
         }
 
-    def collective_config(self) -> CollectiveConfig:
-        """Create a CollectiveConfig for this clips configuration."""
-        return CollectiveConfig(name="clips")
+    def collectives(self) -> dict[str, CollectiveConfig]:
+        """Create collectives for clips."""
+        if self.disabled:
+            return {}
+        return {"clips": CollectiveConfig(name="clips")}

cogames/cogs_vs_clips/cog.py

@@ -4,6 +4,7 @@ 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 (
@@ -11,6 +12,8 @@ from mettagrid.config.mettagrid_config import (
     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
 
@@ -35,12 +38,12 @@ 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": 3})
+    action_cost: dict[str, int] = Field(default_factory=lambda: {"energy": 4})
 
     def agent_config(self, team: str, max_steps: int) -> AgentConfig:
         """Create an AgentConfig for this cog configuration."""
@@ -62,20 +65,28 @@ class CogConfig(Config):
                         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(