document beginner evaluation workflow and result summaries (part 2)

tools/materialize.py

@@ -20,6 +20,32 @@ def normalize_task_id(value: str) -> str:
     return f"{int(raw):03d}"
 
 
+def expand_task_selectors(values: list[str] | None) -> set[str] | None:
+    """Expand repeated, comma-separated ids and inclusive id ranges."""
+    if not values:
+        return None
+    selected: set[str] = set()
+    for value in values:
+        for selector in value.split(","):
+            selector = selector.strip()
+            if not selector:
+                continue
+            if "-" not in selector:
+                selected.add(normalize_task_id(selector))
+                continue
+            pieces = [piece.strip() for piece in selector.split("-")]
+            if len(pieces) != 2 or not all(pieces):
+                raise ValueError(f"invalid task range: {selector!r}")
+            start = int(normalize_task_id(pieces[0]))
+            end = int(normalize_task_id(pieces[1]))
+            if start > end:
+                raise ValueError(f"task range must be ascending: {selector!r}")
+            selected.update(f"{task_id:03d}" for task_id in range(start, end + 1))
+    if not selected:
+        raise ValueError("at least one task id is required")
+    return selected
+
+
 def load_rows() -> list[dict[str, object]]:
     return [json.loads(line) for line in (ROOT / "manifests" / "tasks.jsonl").read_text(encoding="utf-8").splitlines() if line.strip()]
 
@@ -37,8 +63,14 @@ def task_source(task_path: str, *, root: Path = ROOT) -> Path:
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--output", type=Path, default=ROOT / "tasks-selected")
-    parser.add_argument("--task-id", action="append", dest="task_ids")
-    parser.add_argument("--allow-GPL", action="store_true", dest="allow_gpl")
+    parser.add_argument(
+        "--task-id", action="append", dest="task_ids",
+        help="Task id selector; repeat or use commas/ranges, e.g. 002,005-007",
+    )
+    parser.add_argument(
+        "--allow-GPL", "--allow-gpl", action="store_true", dest="allow_gpl",
+        help="Allow the 12 GPL-family tasks in the materialized selection",
+    )
     parser.add_argument(
         "--include-build-context",
         action="store_true",
@@ -46,15 +78,23 @@ def main() -> int:
     )
     parser.add_argument("--force", action="store_true")
     args = parser.parse_args()
-    selected = {normalize_task_id(value) for value in args.task_ids} if args.task_ids else None
-    rows = []
-    for row in load_rows():
-        task_id = str(row["release_id"])
-        if selected is not None and task_id not in selected:
-            continue
-        if bool(row.get("gpl_family")) and not args.allow_gpl:
-            continue
-        rows.append(row)
+    selected = expand_task_selectors(args.task_ids)
+    available_rows = load_rows()
+    available_ids = {str(row["release_id"]) for row in available_rows}
+    if selected is not None:
+        unknown = selected - available_ids
+        if unknown:
+            raise ValueError(f"unknown task ids: {', '.join(sorted(unknown))}")
+    matched = [
+        row for row in available_rows
+        if selected is None or str(row["release_id"]) in selected
+    ]
+    gated = [str(row["release_id"]) for row in matched if bool(row.get("gpl_family"))]
+    if gated and not args.allow_gpl:
+        raise ValueError(
+            "GPL-family task selection requires --allow-GPL: " + ", ".join(gated)
+        )
+    rows = [row for row in matched if args.allow_gpl or not bool(row.get("gpl_family"))]
     if args.output.exists():
         if not args.force:
             raise FileExistsError(f"output exists; use --force: {args.output}")

tools/run_batch.py

@@ -17,6 +17,11 @@ try:
 except ImportError:  # Direct execution: python3 scripts/run_batch.py
     from provider_config import parse_dotenv, render_codex_config, resolve_codex_profile
 
+try:
+    from .summarize_results import write_summary
+except ImportError:  # Direct execution: python3 scripts/run_batch.py
+    from summarize_results import write_summary
+
 try:
     import tomllib
 except ModuleNotFoundError:  # Python 3.10 and earlier
@@ -93,11 +98,28 @@ def redacted_command(command: list[str]) -> str:
             redacted.extend([value, "config_toml=<provider-config>"])
             index += 2
             continue
+        if "=" in value:
+            key = value.split("=", 1)[0].lower()
+            if any(marker in key for marker in ("key", "token", "secret", "password", "authorization")):
+                redacted.append(key + "=<redacted>")
+                index += 1
+                continue
         redacted.append(value)
         index += 1
     return shlex.join(redacted)
 
 
+def pier_version(pier_bin: str) -> str | None:
+    try:
+        completed = subprocess.run(
+            [pier_bin, "--version"], capture_output=True, text=True, check=False
+        )
+    except OSError:
+        return None
+    value = (completed.stdout or completed.stderr).strip()
+    return value or None
+
+
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--path", type=Path, required=True, help="Materialized task directory")
@@ -205,6 +227,12 @@ def main() -> int:
         "selection_sha256": selection["selection_sha256"],
         "image_refs": image_refs,
         "platform": args.platform,
+        "agent": args.agent,
+        "models": models,
+        "n_concurrent": args.n_concurrent,
+        "n_attempts": args.n_attempts,
+        "max_retries": args.max_retries,
+        "pier_version": pier_version(args.pier_bin),
         "pier_command": redacted_command(command),
         "agent_import_path": agent_import_path,
         "provider": provider_metadata,
@@ -223,7 +251,13 @@ def main() -> int:
     pier_environment["PYTHONPATH"] = os.pathsep.join(
         value for value in (tool_root, existing_pythonpath) if value
     )
-    return subprocess.run(command, check=False, env=pier_environment).returncode
+    returncode = subprocess.run(command, check=False, env=pier_environment).returncode
+    try:
+        summary_json, summary_csv = write_summary(args.jobs_dir)
+        print(json.dumps({"summary_json": str(summary_json), "summary_csv": str(summary_csv)}, indent=2))
+    except (OSError, ValueError) as exc:
+        print(f"warning: unable to write result summary: {exc}", file=sys.stderr)
+    return returncode
 
 
 if __name__ == "__main__":

tools/summarize_results.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Flatten Pier job outputs into a small JSON and CSV evaluation summary."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+TRIAL_RE = re.compile(r"^(task_\d{3})__(.+)$")
+FIELDS = (
+    "task_id", "trial_id", "reward", "public_passed", "public_collected",
+    "private_passed", "private_collected", "failure_class", "verifier_dir",
+)
+
+
+def _load_json(path: Path) -> dict[str, object]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def _failure_by_trial(job_result: dict[str, object]) -> dict[str, str]:
+    output: dict[str, str] = {}
+    stats = job_result.get("stats")
+    if not isinstance(stats, dict):
+        return output
+    evaluations = stats.get("evals")
+    if not isinstance(evaluations, dict):
+        return output
+    for evaluation in evaluations.values():
+        if not isinstance(evaluation, dict):
+            continue
+        exceptions = evaluation.get("exception_stats")
+        if not isinstance(exceptions, dict):
+            continue
+        for failure_class, trials in exceptions.items():
+            if isinstance(trials, list):
+                for trial in trials:
+                    output[str(trial)] = str(failure_class)
+    return output
+
+
+def collect_rows(jobs_dir: Path) -> list[dict[str, object]]:
+    rows: list[dict[str, object]] = []
+    for job_dir in sorted(path for path in jobs_dir.iterdir() if path.is_dir()):
+        job_result = _load_json(job_dir / "result.json")
+        failure_by_trial = _failure_by_trial(job_result)
+        for trial_dir in sorted(path for path in job_dir.iterdir() if path.is_dir()):
+            match = TRIAL_RE.match(trial_dir.name)
+            if not match:
+                continue
+            reward = _load_json(trial_dir / "verifier" / "reward.json")
+            public = reward.get("public") if isinstance(reward.get("public"), dict) else {}
+            private = reward.get("private") if isinstance(reward.get("private"), dict) else {}
+            rows.append(
+                {
+                    "task_id": match.group(1).removeprefix("task_"),
+                    "trial_id": trial_dir.name,
+                    "reward": reward.get("reward", ""),
+                    "public_passed": public.get("passed", ""),
+                    "public_collected": public.get("collected", ""),
+                    "private_passed": private.get("passed", ""),
+                    "private_collected": private.get("collected", ""),
+                    "failure_class": failure_by_trial.get(trial_dir.name, ""),
+                    "verifier_dir": str(trial_dir / "verifier"),
+                }
+            )
+    return rows
+
+
+def write_summary(jobs_dir: Path, output_dir: Path | None = None) -> tuple[Path, Path]:
+    jobs_dir = jobs_dir.resolve()
+    output_dir = (output_dir or jobs_dir).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    rows = collect_rows(jobs_dir)
+    payload = {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "jobs_dir": str(jobs_dir),
+        "trial_count": len(rows),
+        "rows": rows,
+    }
+    json_path = output_dir / "summary.json"
+    csv_path = output_dir / "summary.csv"
+    json_path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    with csv_path.open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=FIELDS, lineterminator="\n")
+        writer.writeheader()
+        writer.writerows(rows)
+    return json_path, csv_path
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--jobs-dir", type=Path, default=Path("jobs"))
+    parser.add_argument("--output-dir", type=Path)
+    args = parser.parse_args()
+    json_path, csv_path = write_summary(args.jobs_dir, args.output_dir)
+    print(json.dumps({"summary_json": str(json_path), "summary_csv": str(csv_path)}, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())