feat(balatrobench): update strategies to match model format

Author: S1M0N38

src/balatrobench/analyzer.py

@@ -125,11 +125,14 @@ def _compute_runs(self, model_dir: Path) -> Runs | None:
 
             # Load strategy (once)
             if strategy_obj is None:
+                strategy_key = source_task["strategy"]
+
                 if strategy_file.exists():
                     with strategy_file.open() as f:
                         source_strategy: SourceStrategy = json.load(f)
                     strategy_obj = Strategy(
                         name=source_strategy["name"],
+                        key=strategy_key,
                         description=source_strategy["description"],
                         author=source_strategy["author"],
                         version=source_strategy["version"],
@@ -138,6 +141,7 @@ def _compute_runs(self, model_dir: Path) -> Runs | None:
                 else:
                     strategy_obj = Strategy(
                         name=source_task["strategy"],
+                        key=strategy_key,
                         description="",
                         author="",
                         version="",

src/balatrobench/cli.py

@@ -100,14 +100,15 @@ def main() -> None:
 
             # Get strategy from first Runs
             strategy = runs_list[0].strategy
+            strategy_key = strategy.key
 
             # Write leaderboard
             leaderboard = analyzer.create_models_leaderboard(strategy, runs_list)
-            models_writer.write_models_leaderboard(leaderboard, version, strategy_name)
+            models_writer.write_models_leaderboard(leaderboard, version, strategy_key)
 
             # Write model runs and request files
             for runs in runs_list:
-                models_writer.write_runs(runs, version, strategy_name)
+                models_writer.write_runs(runs, version, strategy_key)
 
                 # Write per-request files for each run
                 for run in runs.runs:
@@ -122,7 +123,7 @@ def main() -> None:
                         output_base = (
                             models_output_dir
                             / version
-                            / strategy_name
+                            / strategy_key
                             / runs.model.vendor
                             / runs.model.name
                         )
@@ -150,10 +151,20 @@ def main() -> None:
                 leaderboard, version, model_key
             )
 
-            # Write strategy runs
+            # Write strategy runs and request files
             for runs in runs_list:
                 strategies_writer.write_strategy_runs(runs, version, vendor, model_name)
 
+                # Write per-request files for each run
+                strategy_key = runs.strategy.key
+                for run in runs.runs:
+                    # Find run directory in input
+                    run_dir = input_dir / strategy_key / vendor / model_name / run.id
+                    if run_dir.exists():
+                        strategies_writer.write_strategy_request_files(
+                            run_dir, version, vendor, model_name, strategy_key, run.id
+                        )
+
         # Convert PNGs to WebP if enabled
         if args.webp:
             print("\nConverting PNG screenshots to WebP format...")

src/balatrobench/models.py

@@ -84,6 +84,7 @@ class Strategy:
     """Strategy metadata."""
 
     name: str
+    key: str
     description: str
     author: str
     version: str

src/balatrobench/writer.py

@@ -108,18 +108,38 @@ def write_strategy_runs(
     ) -> Path:
         """Write runs.json for a strategy (when analyzing strategies per model).
 
+        Output: {version}/{vendor}/{model}/{strategy_key}/runs.json
+
         Returns the path to the written file.
         """
         output_path = (
             self.output_dir
             / version
             / vendor
             / model_name
-            / runs.strategy.name
+            / runs.strategy.key
             / "runs.json"
         )
         return self._write_json(output_path, runs)
 
+    def write_strategy_request_files(
+        self,
+        run_dir: Path,
+        version: str,
+        vendor: str,
+        model_name: str,
+        strategy_key: str,
+        run_id: str,
+    ) -> None:
+        """Extract and write per-request files for a strategy run.
+
+        Output: {version}/{vendor}/{model}/{strategy_key}/{run_id}/{request_id}/
+        Each containing: reasoning.md, tool_call.json, strategy.md, gamestate.md,
+        memory.md, metadata.json, and screenshot.png (if available).
+        """
+        output_base = self.output_dir / version / vendor / model_name / strategy_key
+        self._write_request_files_impl(run_dir, output_base)
+
     def write_request_files(
         self,
         run_dir: Path,
@@ -131,6 +151,19 @@ def write_request_files(
         Each containing: reasoning.md, tool_call.json, strategy.md, gamestate.md,
         memory.md, metadata.json, and screenshot.webp (if available).
         """
+        self._write_request_files_impl(run_dir, output_base)
+
+    def _write_request_files_impl(
+        self,
+        run_dir: Path,
+        output_base: Path,
+    ) -> None:
+        """Internal implementation for writing per-request files.
+
+        Creates directories like: {output_base}/{run_id}/{request_id}/
+        Each containing: reasoning.md, tool_call.json, strategy.md, gamestate.md,
+        memory.md, metadata.json, and screenshot.png (if available).
+        """
         run_id = run_dir.name
         requests_file = run_dir / "requests.jsonl"
         responses_file = run_dir / "responses.jsonl"