Refine ladder win conditions, block binary pushes, quiet console logs

Author: john-b-yang

codeclash/agents/player.py

@@ -196,8 +196,13 @@ def _get_commit_hash(self) -> str:
     def _commit(self) -> None:
         """Commit changes to the agent's codebase."""
         r = self.game_context.round
+        unstage_binaries = (
+            "git diff --cached --numstat | awk -F'\\t' '$1==\"-\" && $2==\"-\" {print $3}' "
+            "| xargs -r -d '\\n' git reset -q HEAD --"
+        )
         for cmd in [
             "git add -A",
+            unstage_binaries,
             f"git commit --allow-empty -m 'Round {r} Update'",
         ]:
             assert_zero_exit_code(self.environment.execute(cmd), logger=self.logger)

codeclash/cli/ladder.py

@@ -21,10 +21,12 @@
 def _resolve_ladder_rules(ladder_rules: dict, rounds: int) -> tuple[float, int]:
     """Validate the optional ``ladder_rules`` block and return ``(min_round_win_fraction, win_last_k)``.
 
-    Defaults reproduce the historical behavior: win a strict majority of rounds
-    (``min_round_win_fraction=0.5``) AND win the final round (``win_last_k=1``).
+    Defaults: win at least ``min_round_win_fraction`` (0.4) of the *agent* rounds AND win the last
+    ``win_last_k`` (1) round(s). The baseline round 0 (identical, un-edited codebases) is excluded
+    from this count — it reflects game variance, not the agent — so the fraction is taken over the
+    ``rounds`` rounds the agent actually edits.
     """
-    min_round_win_fraction = ladder_rules.get("min_round_win_fraction", 0.5)
+    min_round_win_fraction = ladder_rules.get("min_round_win_fraction", 0.4)
     win_last_k = ladder_rules.get("win_last_k", 1)
 
     # win_last_k: number of trailing rounds the player must win (1 == just the final round).
@@ -40,14 +42,15 @@ def _resolve_ladder_rules(ladder_rules: dict, rounds: int) -> tuple[float, int]:
         typer.echo(f"ladder_rules.win_last_k ({win_last_k}) cannot exceed tournament.rounds ({rounds}).")
         raise typer.Exit(1)
 
-    # min_round_win_fraction: player must win strictly more than this fraction of rounds.
+    # min_round_win_fraction: player must win >= this fraction of the agent rounds (round 0 excluded).
     if isinstance(min_round_win_fraction, bool) or not isinstance(min_round_win_fraction, (int, float)):
         typer.echo(f"ladder_rules.min_round_win_fraction must be a number, got {min_round_win_fraction!r}.")
         raise typer.Exit(1)
-    if not 0 <= min_round_win_fraction < 1:
+    if not 0 <= min_round_win_fraction <= 1:
         typer.echo(
-            f"ladder_rules.min_round_win_fraction must be in [0, 1), got {min_round_win_fraction}. "
-            "0.5 requires a strict majority; 0 drops the majority requirement."
+            f"ladder_rules.min_round_win_fraction must be in [0, 1], got {min_round_win_fraction}. "
+            "The player must win >= this fraction of the agent rounds; 1 requires winning all of them, "
+            "0 drops the fraction requirement."
         )
         raise typer.Exit(1)
 
@@ -145,8 +148,8 @@ def run(
     config.pop("ladder_rules", None)
 
     print(
-        f"Ladder advancement rule: win > {min_round_win_fraction:.0%} of {rounds} rounds "
-        f"and win the last {win_last_k} round(s)."
+        f"Ladder advancement rule: win >= {min_round_win_fraction:.0%} of {rounds} agent rounds "
+        f"(baseline round 0 excluded) and win the last {win_last_k} round(s)."
     )
     ladder_folder = f"LadderTournament.{config['game']['name']}.r{rounds}.s{sims}.{timestamp}"
     player["branch"] = ladder_folder
@@ -185,21 +188,21 @@ def run(
         metadata_path = tournament_dir / "metadata.json"
         with open(metadata_path) as f:
             metadata = yaml.safe_load(f)
-        round_winners = [r["winner"] for r in metadata["round_stats"].values()]
+        round_winners = [r["winner"] for k, r in metadata["round_stats"].items() if int(k) != 0]
 
-        # Advancement rule (configurable via `ladder_rules`): win strictly more than
-        # `min_round_win_fraction` of rounds AND win the last `win_last_k` rounds.
+        # Advancement rule (configurable via `ladder_rules`): win at least
+        # `min_round_win_fraction` of the agent rounds AND win the last `win_last_k` rounds.
         player_wins = sum(1 for w in round_winners if w == player["name"])
-        won_majority = player_wins > len(round_winners) * min_round_win_fraction
+        won_majority = player_wins >= len(round_winners) * min_round_win_fraction
         won_last_k = all(w == player["name"] for w in round_winners[-win_last_k:])
 
         if not won_majority or not won_last_k:
             # Player failed the advancement rule; the ladder challenge ends here.
             print("=" * 10)
             print(
                 f"{player['name']} did not clear {opponent['name']} "
-                f"(rank {opponent_rank}/{len(ladder)}): won {player_wins}/{len(round_winners)} rounds "
-                f"(needed > {min_round_win_fraction:.0%}), last {win_last_k} round(s) won: {won_last_k}.\n"
+                f"(rank {opponent_rank}/{len(ladder)}): won {player_wins}/{len(round_winners)} agent rounds "
+                f"(needed >= {min_round_win_fraction:.0%}), last {win_last_k} round(s) won: {won_last_k}.\n"
                 "Ladder challenge ends."
             )
             print("=" * 10)

codeclash/utils/log.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 import logging
+import os
 from pathlib import Path
 
 from rich.console import Console
 from rich.text import Text
 
-_STREAM_LEVEL = logging.DEBUG
+_STREAM_LEVEL = getattr(logging, os.getenv("CODECLASH_LOG_LEVEL", "INFO").upper(), logging.INFO)
 _FILE_LEVEL = logging.DEBUG
 
 # logging.getLogger().setLevel(logging.DEBUG)

codeclash/utils/yaml_utils.py

@@ -23,9 +23,6 @@ def include_replacer(match):
         if prefix.strip() == "<<:":
             # For merge keys, include the content with proper indentation
             if indentation:
-                # Merged content must be indented deeper than the `<<:` key itself, otherwise
-                # the key gets a null scalar and PyYAML rejects the merge. (+2 spaces, matching
-                # the no-indentation branch below.)
                 content_indent = indentation + "  "
                 included_lines = included_content.splitlines()
                 indented_lines = [content_indent + line if line.strip() else line for line in included_lines]

configs/ablations/ladder/battlesnake_llama_smoke.yaml

@@ -1,13 +1,13 @@
 # Cheap smoke to validate the llama-endpoint wiring before a full ladder run:
 # Opus 4.8 (native Anthropic API via AnthropicModel) climbs a 2-rung BattleSnake ladder.
-# 1 round, 10 sims — just enough to confirm the model authenticates, caches, and edits code.
+# 2 rounds, 10 sims — just enough to confirm the model authenticates, caches, and edits code.
 # Requires LLAMA_API_KEY in .env.
 #   uv run codeclash ladder run configs/ablations/ladder/battlesnake_llama_smoke.yaml -c
 tournament:
-  rounds: 1
+  rounds: 2
 ladder_rules:
-  min_round_win_fraction: 0.5   # advance only on a strict majority of rounds
-  win_last_k: 1                 # ...and win the last K rounds (K=1 == just the final round)
+  min_round_win_fraction: 0.5   # win >= half the agent rounds (round 0 excluded)
+  win_last_k: 1                 # ...and win the last K rounds (K=1 == the final round)
 game:
   name: BattleSnake
   sims_per_round: 10

configs/mini/default.yaml

@@ -101,4 +101,4 @@ instance_template: |
   run exactly `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT` to submit your work.
   You cannot continue working in any way on this task after submitting.
 step_limit: 30
-cost_limit: 0    # 0 disables the cost cap (see agents/default.py: limit applies only when >0); step_limit is the sole stop
+cost_limit: 0