#!/usr/bin/env python3
# SPDX-License-Identifier: FSL-1.1-MIT
# Copyright (c) 2026 Cua AI, Inc.
"""Claude Code computer-use benchmark runner: same model, same harness, two MCP tool layers.
run_bench.py preflight --run-id NAME [--build-dir DIR]
run_bench.py dry-run --phase1-runs 3 --phase2-runs 2
run_bench.py run --run-id NAME --build-dir DIR --phase1-runs 3 --phase2-runs 2 \
--cutoff-utc 2026-10-06T03:00:00Z
run_bench.py status --run-id NAME
Arms (run_bench.py never mixes them up with the Codex pilot arms):
cc-cua-driver Claude Code + Cua Driver 0.34.0 MCP + the Cua Driver skill of that release
cc-cua-driver-main the same with Cua Driver built from a pinned main commit and its skill (Amendment 3)
cc-codex-cu Claude Code + Codex computer-use `cua_repl` MCP (server `codex-cu`), no skill
Fallback arms (`codex exec --json`, behind --allow-codex-arms; not run at scale): codex-native-cu,
codex-cua-driver. They reuse run_pilot.py.
Pre-registered rules are in bench_core.py. Per-trial output lives under runs/<run>/trials/<trial id>/.
Run it from a Terminal.app shell (launch_bench.command): the Codex computer-use service refuses
clients whose responsible app cannot show the macOS Automation prompt.
"""
from __future__ import annotations
import argparse
import base64
import contextlib
import hashlib
import json
import math
import os
import platform
import re
import shutil
import signal
import subprocess
import sys
import tempfile
import threading
import time
from dataclasses import dataclass, field
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
sys.path.insert(0, str(HERE / "swift"))
import arms # noqa: E402
import bench_v2 as v2 # noqa: E402
import bench_core as core # noqa: E402
import claude_arms as ca # noqa: E402
import cdb_adapter # noqa: E402
import codex_native as cxn # noqa: E402
import pi_arms as pia # noqa: E402
import browser_use_cli as bu
import claude_driver # noqa: E402
import claude_events # noqa: E402
import recorder as rec # noqa: E402
import run_pilot as pilot # noqa: E402
import desktop_runtime as desktop
from dataclasses import replace
SCHEMA = "cdb-bench-trial/1"
# The Claude Code arm whose driver build, MCP entry, skill and system prompt a Codex or pi arm uses
SOURCE_ARM = {**cxn.SOURCE_ARM, **pia.SOURCE_ARM}
# Arms that use no Claude seat: no quota gate, no Haiku probes
NO_CLAUDE_SEAT = cxn.ARMS + pia.ARMS
WEB_TASKS = ("WEB-01", "WEB-02")
WORK = ca.WORK
DEFAULT_LEDGER = WORK / "ledger" / "spend.jsonl"
DEFAULT_RUNS = WORK / "runs"
DISK_FLOOR_GB = 80.0
PRICE_FALLBACK = { # USD per million tokens, ASSUMED list prices, used only when no total_cost_usd exists
"input": 3.0,
"output": 15.0,
"cache_read": 0.30,
"cache_write": 6.0,
}
class StopRun(Exception):
def __init__(self, reason: str, detail: str = "") -> None:
super().__init__(f"{reason}: {detail}")
self.reason, self.detail = reason, detail
# ---------------------------------------------------------------- tasks
def task_selector_files(probes_dir: Path) -> list[Path]:
"""Selectors of this repository, plus those of the held-out pack when `CDB_TASKPACK_HELDOUT` is set
(`<held-out pack>/probes/<ID>/task.json`, `"split": "heldout"`)."""
files = sorted(probes_dir.glob("*/task.json"))
heldout = os.environ.get("CDB_TASKPACK_HELDOUT")
if heldout:
files += sorted((Path(heldout) / "probes").glob("*/task.json"))
return files
def load_tasks(probes_dir: Path) -> dict[str, pilot.Task]:
tasks: dict[str, pilot.Task] = {}
for meta in task_selector_files(probes_dir):
data = json.loads(meta.read_text("utf-8"))
if data.get("status") == "dropped":
continue # kept on disk, not run (PREREGISTRATION.md, amendment of 6 Oct)
task = pilot.Task(
data["id"],
"probe",
int(data.get("timeout_s", 240)),
list(data.get("dimension_tags", [])),
probe_dir=meta.parent,
app_args=list(data.get("app_args", [])),
)
task.spec = data # type: ignore[attr-defined]
tasks[task.id] = task
return tasks
def default_task(tasks: dict[str, pilot.Task], task_id: str) -> bool:
"""In the default schedule: MB-* and CDB-* tasks except those that run in their own run (`separate_run`)."""
return task_id.startswith(("MB-", "CDB-")) and not task_spec(tasks[task_id]).get("separate_run")
def task_spec(task: pilot.Task) -> dict[str, Any]:
return getattr(task, "spec", {})
def allowed_apps(task: pilot.Task) -> set[str]:
spec = task_spec(task)
names = {"BenchLab", *spec.get("needs_apps", []), *spec.get("allowed_apps", [])}
out = {n.lower() for n in names}
if spec.get("kind") == "cdb":
out |= cdb_adapter.allowed_app_names(spec)
return out
# ---------------------------------------------------------------- context
@dataclass
class Ctx:
args: argparse.Namespace
run_dir: Path
ledger: core.Ledger
tasks: dict[str, pilot.Task]
task_ids: list[str]
arm_names: list[str]
full_task_ids: list[str] = field(default_factory=list) # positions in the pre-registered order
mcp: dict[str, tuple[Path, str]] = field(default_factory=dict)
recorder: Any = None
compress: rec.CompressQueue | None = None
daemon: subprocess.Popen[bytes] | None = None
daemon_arm: str | None = (
None # which Cua Driver build the agent daemon belongs to (one at a time)
)
rec_daemon: subprocess.Popen[bytes] | None = None
quota: dict[str, Any] | None = None
cutoff: float | None = None
versions: dict[str, Any] = field(default_factory=dict)
state: dict[str, Any] = field(default_factory=dict)
lock: threading.Lock = field(default_factory=threading.Lock)
abort: threading.Event = field(default_factory=threading.Event)
block_durations: list[float] = field(default_factory=list)
def blocks(self) -> list[dict[str, Any]]:
"""Task-major blocks. Positions come from the full ordered list so ``--only-task`` keeps the
pre-registered first-arm parity."""
blocks = core.build_blocks(
self.full_task_ids or self.task_ids,
self.arm_names,
self.args.phase1_runs,
self.args.phase2_runs,
self.args.schedule_seed,
)
kept = [b for b in blocks if b["task"] in self.task_ids]
index = 0
for block in kept:
for entry in block["entries"]:
entry["order_index"] = index
if self.args.smoke:
entry["trial_id"] = "SMOKE-" + entry["trial_id"]
index += 1
return kept
@property
def results_path(self) -> Path:
return self.run_dir / "results.jsonl"
def log(self, message: str) -> None:
line = f"{datetime.now(timezone.utc).strftime('%H:%M:%S')} {message}"
print(line, flush=True)
with (self.run_dir / "runner.log").open("a", encoding="utf-8") as handle:
handle.write(line + "\n")
def set_state(self, **fields: Any) -> None:
with self.lock:
self.state.update(fields)
self.write_heartbeat()
def write_heartbeat(self) -> None:
with self.lock:
state = dict(self.state)
started = state.get("trial_started_mono")
beat = {
"ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
"run_id": self.run_dir.name,
"state": state.get("state", "starting"),
"trial_id": state.get("trial_id"),
"attempt": state.get("attempt"),
"trial_elapsed_s": round(time.monotonic() - started, 1) if started else None,
"trials_done": state.get("trials_done", 0),
"blocks_complete": state.get("blocks_complete", 0),
"blocks_total": state.get("blocks_total", 0),
"phase": state.get("phase"),
"spend_run_usd": round(state.get("spend_run", 0.0), 4),
"spend_ledger_total_usd": self.ledger.cumulative(),
"quota": self.quota,
"pause": state.get("pause"),
"compress_pending": self.compress.pending() if self.compress else 0,
"free_gb": round(rec.free_gb(self.run_dir), 1),
"cutoff_utc": datetime.fromtimestamp(self.cutoff, timezone.utc).isoformat(
timespec="seconds"
)
if self.cutoff
else None,
}
tmp = self.run_dir / "heartbeat.json.tmp"
tmp.write_text(json.dumps(beat, indent=2) + "\n", "utf-8")
tmp.replace(self.run_dir / "heartbeat.json")
def start_heartbeat(ctx: Ctx) -> threading.Event:
stop = threading.Event()
def loop() -> None:
while not stop.wait(30.0):
try:
ctx.write_heartbeat()
except OSError:
pass
threading.Thread(target=loop, daemon=True).start()
return stop
# ---------------------------------------------------------------- helpers
def git_commit(path: Path) -> str:
try:
return (
subprocess.run(
["git", "-C", str(path), "rev-parse", "HEAD"],
capture_output=True,
text=True,
timeout=10,
).stdout.strip()
or "unknown"
)
except (OSError, subprocess.TimeoutExpired):
return "unknown"
def sw_vers() -> str:
if desktop.detect_platform() == "linux":
return os.uname().release
return subprocess.run(
["sw_vers", "-productVersion"], capture_output=True, text=True
).stdout.strip()
def claude_version() -> str:
try:
return subprocess.run(
[str(ca.CLAUDE_BIN), "--version"],
capture_output=True,
text=True,
timeout=30,
env=ca.claude_env(),
).stdout.strip()
except (OSError, subprocess.TimeoutExpired):
return "unavailable"
def src_hash() -> str:
digest = hashlib.sha256()
for path in (
sorted(HERE.glob("*.py"))
+ sorted((HERE / "linux").rglob("*.py"))
+ sorted((HERE / "probes").rglob("*.py"))
+ sorted((HERE / "probes").rglob("*.md"))
+ sorted((HERE / "probes").rglob("task.json"))
):
if "__pycache__" in path.parts:
continue
digest.update(str(path.relative_to(HERE)).encode())
digest.update(path.read_bytes())
return digest.hexdigest()
def strip_bulk(value: Any, limit: int = 4000) -> Any:
"""Replace huge strings (base64 screenshots) so stored stream logs stay small."""
if isinstance(value, str):
return value if len(value) <= limit else f"{value[:120]}...<{len(value)} chars stripped>"
if isinstance(value, list):
return [strip_bulk(v, limit) for v in value]
if isinstance(value, dict):
return {k: strip_bulk(v, limit) for k, v in value.items()}
return value
def strip_stream_file(path: Path) -> int:
"""Rewrite a stream log without bulk payloads. Returns bytes saved."""
if not path.exists():
return 0
before = path.stat().st_size
out: list[str] = []
for raw in path.read_text("utf-8", "replace").splitlines():
head, sep, body = raw.partition("\t") if not raw.startswith("{") else ("", "", raw)
try:
obj = json.loads(body)
except json.JSONDecodeError:
out.append(raw)
continue
text = json.dumps(strip_bulk(obj), separators=(",", ":"))
out.append(f"{head}\t{text}" if sep else text)
path.write_text("\n".join(out) + "\n", "utf-8")
return before - path.stat().st_size
def estimate_cost(tokens: dict[str, int]) -> float:
return round(sum(tokens.get(k, 0) * PRICE_FALLBACK[k] for k in PRICE_FALLBACK) / 1e6, 6)
def terminal_ancestor() -> bool:
"""True when a Terminal.app process is among this process' ancestors."""
pid = os.getpid()
for _ in range(30):
done = subprocess.run(
["ps", "-o", "ppid=,comm=", "-p", str(pid)], capture_output=True, text=True
)
parts = done.stdout.strip().split(None, 1)
if len(parts) < 2:
return False
if "Terminal.app" in parts[1]:
return True
pid = int(parts[0])
if pid <= 1:
return False
return False
def merge_quota(old: dict[str, Any] | None, new: dict[str, Any] | None) -> dict[str, Any] | None:
if not new:
return old
merged = dict(old or {})
for key, value in new.items():
if value is not None:
merged[key] = value
merged["seen_utc"] = datetime.now(timezone.utc).isoformat(timespec="seconds")
return merged
QUOTA_LATEST = WORK / "ledger" / "quota_latest.json"
def note_quota(ctx: Ctx, new: dict[str, Any] | None, source: str) -> None:
"""Persist a fresh reading so the launcher can gate without a model call. Stand-in claude binaries
never write it."""
if (
new
and ctx.args.claude_bin is None
and ctx.ledger.path.resolve() == DEFAULT_LEDGER.resolve()
):
core.persist_quota(QUOTA_LATEST, ctx.quota or new, source)
def sleep_with_heartbeat(ctx: Ctx, seconds: float, reason: str) -> bool:
"""Sleep in short steps. Returns False when interrupted by STOP or abort."""
end = time.monotonic() + seconds
while time.monotonic() < end:
if (ctx.run_dir / "STOP").exists() or ctx.abort.is_set():
return False
time.sleep(min(5.0, max(0.0, end - time.monotonic())))
return True
def log_pause(ctx: Ctx, kind: str, seconds: float, message: str, trial_id: str | None) -> None:
entry = {
"ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
"kind": kind,
"planned_s": round(seconds, 1),
"message": message[:300],
"trial_id": trial_id,
}
with (ctx.run_dir / "pauses.jsonl").open("a", encoding="utf-8") as handle:
handle.write(json.dumps({**entry, "event": "start"}) + "\n")
ctx.log(f"PAUSE {kind} {seconds:.0f}s: {message[:120]}")
ctx.set_state(state="paused", pause=entry)
t0 = time.monotonic()
sleep_with_heartbeat(ctx, seconds, kind)
with (ctx.run_dir / "pauses.jsonl").open("a", encoding="utf-8") as handle:
handle.write(
json.dumps(
{
**entry,
"event": "end",
"ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
"actual_s": round(time.monotonic() - t0, 1),
}
)
+ "\n"
)
ctx.set_state(state="idle", pause=None)
# ---------------------------------------------------------------- LaunchServices copies
LSREGISTER = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister"
BENCH_APPS = ("BenchLab.app", "BenchSentinel.app")
def registered_bench_copies() -> list[str]:
"""Paths of BenchLab/BenchSentinel registered with LaunchServices that still exist on disk.
The Codex computer-use server resolves apps by name or bundle id and refuses an ambiguous
bundle id, so exactly one copy of each may be registered."""
try:
dump = subprocess.run(
[LSREGISTER, "-dump"], capture_output=True, text=True, timeout=180
).stdout
except (OSError, subprocess.TimeoutExpired):
return []
found = {m.strip() for m in re.findall(r"^path:\s+(.*?\.app)\s+\(0x", dump, re.M)}
return sorted(p for p in found if Path(p).name in BENCH_APPS and Path(p).exists())
def unregister_stale_copies(build_dir: Path | None) -> list[str]:
"""Reversible: lsregister -u for copies outside the build dir (files are left alone)."""
keep = Path(build_dir).resolve() if build_dir else None
gone = []
for path in registered_bench_copies():
if keep and Path(path).resolve().parent == keep:
continue
subprocess.run([LSREGISTER, "-u", path], capture_output=True, timeout=60)
gone.append(path)
return gone
# ---------------------------------------------------------------- daemons and arms
def stop_agent_daemons(ctx: Ctx, keep: str | None = None) -> None:
"""Stop the agent daemon of every Cua Driver build except ``keep`` (one build runs at a time)."""
if ctx.daemon is not None and ctx.daemon_arm != keep:
claude_driver.kill_group(ctx.daemon.pid)
ctx.daemon = None
ctx.daemon_arm = None
for arm, build in ca.CUA_BUILDS.items():
if arm != keep and build.bin.is_file():
ca.stop_cua_daemon(build.socket, build.home, build.bin)
def ensure_agent_daemon(ctx: Ctx, arm: str = "cc-cua-driver") -> None:
build = ca.CUA_BUILDS[arm]
if ctx.daemon_arm != arm:
stop_agent_daemons(ctx, keep=None)
done = subprocess.run(
[str(build.bin), "status", "--socket", build.socket],
env=ca.cua_env(build.home),
capture_output=True,
text=True,
timeout=15,
)
if done.returncode == 0 and ctx.daemon_arm == arm:
return
if ctx.daemon_arm == arm:
ctx.log(f"agent daemon of {arm} not answering; restarting")
if ctx.daemon is not None:
claude_driver.kill_group(ctx.daemon.pid)
ca.stop_cua_daemon(build.socket, build.home, build.bin)
ctx.daemon = ca.start_cua_daemon(
build.socket, build.state, binary=build.bin, env_extra=dict(build.daemon_env)
)
ctx.daemon_arm = arm
def check_pins(pins: dict[str, Any], arm_names: list[str]) -> list[tuple[str, str, str]]:
"""Compare every pinned version and hash with what is installed now. Any difference fails."""
observed = ca.observed_pins(
include_codex=any(a in ca.CODEX_ARMS or a in cxn.ARMS for a in arm_names),
include_cua="cc-cua-driver" in {SOURCE_ARM.get(a, a) for a in arm_names},
)
if (
"cc-codex-cu-1007-browser" in arm_names
): # Amendment 10: that arm's app, plugin and service pins
pins = {
**pins,
**{k: v for k, v in pins.get("codex_1007", {}).items() if not k.startswith("_")},
}
out: list[tuple[str, str, str]] = []
for key, want, got, ok in core.compare_pins(pins, observed):
if key not in observed:
continue # pin of an arm that is not part of this run
out.append(
(
f"pin {key}",
"pass" if ok else "fail",
str(got) if ok else f"observed {got!r}, pinned {want!r}",
)
)
return out
def check_daemon(pins: dict[str, Any], arm: str = "cc-cua-driver") -> list[tuple[str, str, str]]:
spec = ca.CUA_BUILDS[arm]
health = ca.cua_health(spec.socket, spec.home, spec.bin)
build = health.get("build", {})
if arm == "cc-cua-driver":
ok_version = build.get("version") == pins["cua_driver_version"]
ok_sha = build.get("exe_sha256") == pins["cua_driver_binary_sha256"] and build.get(
"git_sha"
) == pins.get("cua_driver_git_sha", build.get("git_sha"))
else: # Amendment 3: the main build is pinned by commit and binary hash, not by a release version
main = pins.get("cua_main", {})
ok_version = build.get("version") == main.get("version")
ok_sha = build.get("exe_sha256") == main.get(spec.binary_pin) and build.get(
"git_sha"
) == main.get("git_sha")
checks = health.get("checks", {})
perms = desktop.capabilities_ok(health)
return [
(
f"{arm} daemon reports version",
"pass" if ok_version else "fail",
str(build.get("version")),
),
(
f"{arm} daemon exe sha256 and git sha match the pins",
"pass" if ok_sha else "fail",
f"{build.get('exe_sha256')} {build.get('git_sha')}",
),
(
f"{arm} daemon accessibility + screen recording",
"pass" if perms else "fail",
json.dumps({k: v for k, v in checks.items() if k.startswith("tcc_")}),
),
]
def mcp_list_tools(command: str, args: list[str], env: dict[str, str]) -> list[str]:
client = rec.McpStdioClient([command, *args], env)
try:
reply = client.request("tools/list", {}, timeout=60)
return [t["name"] for t in reply.get("result", {}).get("tools", [])]
finally:
client.close()
@contextlib.contextmanager
def capture_subject(work: Path):
"""On Linux the capture check needs a window to look at: an empty desktop is a uniform frame, which the
check rightly rejects. Show a BenchLab window for its duration (macOS opens Calculator instead)."""
if desktop.detect_platform() != "linux":
yield
return
work.mkdir(parents=True, exist_ok=True)
args = [
*desktop.bench_app_argv("BenchLab"),
*["--mode", "hover", "--seed", "1"],
*["--state", str(work / "state.json"), "--events", str(work / "events.jsonl")],
]
proc = desktop.start_app(args, work, work / "lab.log")
try:
deadline = time.monotonic() + 20
while (
time.monotonic() < deadline
and not (work / "state.json").exists()
and proc.poll() is None
):
time.sleep(0.2)
yield
finally:
desktop.stop_group(proc.pid)
proc.wait(timeout=5)
def real_capture_check(ctx: "Ctx", arm: str) -> tuple[str, str, str]:
client = None
try:
source = SOURCE_ARM.get(arm, arm)
path, _ = ctx.mcp[arm]
if source in ca.CUA_ARMS:
ensure_agent_daemon(ctx, source)
if arm in cxn.ARMS:
entry = cxn.server_entry(path, arm)
command, args, env = entry["command"], entry["args"], entry["env"]
else:
command, args, env = mcp_entry(path)
client = rec.McpStdioClient(
[command, *args],
env,
elicitation=lambda text: claude_driver.answer_elicitation(text, {"calculator"}),
)
def call(name: str, arguments: dict[str, Any]) -> dict[str, Any]:
reply = client.request("tools/call", {"name": name, "arguments": arguments}, timeout=60)
result = reply.get("result") or {}
if reply.get("error") or result.get("isError"):
raise RuntimeError(
claude_events._text_of(result.get("content"))[:300]
or str(reply.get("error"))[:300]
)
return result
listed = client.request("tools/list", {}, timeout=60)
if listed.get("error"):
raise RuntimeError(str(listed["error"])[:300])
tools = {t["name"]: t for t in (listed.get("result") or {}).get("tools", [])}
dest = ctx.run_dir / "preflight-capture" / arm / "capture.png"
dest.parent.mkdir(parents=True, exist_ok=True)
dest.unlink(missing_ok=True)
if source in ca.CUA_ARMS:
if (
"list_apps" not in tools
or len(tools) < 50
or ("run_script" in tools) != (ca.SCRIPT_FLAG in ca.CUA_BUILDS[source].daemon_env)
):
raise RuntimeError("unexpected Cua Driver tools/list")
call("check_permissions", {})
tool = next((t for t in ("get_desktop_state", "screenshot") if t in tools), None)
if tool is None:
raise RuntimeError("no desktop capture tool")
arguments = (
{"screenshot_out_file": str(dest)}
if "screenshot_out_file" in tools[tool].get("inputSchema", {}).get("properties", {})
else {}
)
result = call(tool, arguments)
elif source in ca.CU_HELPER_ARMS:
if set(tools) != set(ca.load_pins()["claude_cu_helper"]["tools"]):
raise RuntimeError("unexpected helper tools/list")
windows = json.loads(
claude_events._text_of(
call("app_list_windows", {"app": "Calculator"}).get("content")
)
)
window = next((w for w in windows if w.get("app") == "Calculator"), None)
if window is None:
raise RuntimeError("no layer-0 Calculator window")
result = call("app_screenshot", {"app": "Calculator", "window_id": window["window_id"]})
elif source in ca.ADAPTER_ARMS:
# No capture tool: the adapters have no screenshot of the whole desktop. A read-only list proves the
# vendor tool answers through the adapter.
if source == "cc-agent-desktop":
if "list_apps" not in tools:
raise RuntimeError("unexpected agent-desktop tools/list")
call("list_apps", {})
else:
if "macos_harness" not in tools:
raise RuntimeError("unexpected macos-harness tools/list")
call("macos_harness", {"command": "macos-harness list_apps"})
return f"{arm} adapter answers", "pass", "tools/list and a read-only call"
else:
if not {"js", "js_reset"} <= tools.keys():
raise RuntimeError("missing Codex tools")
result = call(
"js",
{"code": 'const app = await cua.getApp("Calculator"); await app.getScreenshot();'},
)
image = next(
(b for b in result.get("content") or [] if b.get("type") == "image" and b.get("data")),
None,
)
if image is not None:
dest.write_bytes(base64.b64decode(image["data"], validate=True))
elif not dest.is_file():
raise RuntimeError("no image block")
return f"{arm} real capture", "pass", rec.capture_detail(dest)
except Exception as error:
return f"{arm} real capture", "fail", f"{type(error).__name__}: {error}"[:400]
finally:
if client is not None:
client.close()
def cu_helper_probe(
helper: Path, launcher: Path | None = None, timeout: float = 20.0
) -> dict[str, Any]:
"""Amendment 11: the helper's own ``probe`` (capability flags), asked directly over its JSON-RPC stdin/stdout,
started through the same launcher as in a trial (so ``axTrusted`` is the helper's own grant)."""
proc = subprocess.run(
[str(launcher), str(helper)] if launcher else [str(helper)],
input=json.dumps({"jsonrpc": "2.0", "id": 1, "method": "probe", "params": {}}) + "\n",
capture_output=True,
text=True,
timeout=timeout,
env={"PATH": "/usr/bin:/bin", "HOME": os.environ.get("HOME", "")},
)
for line in proc.stdout.splitlines():
try:
reply = json.loads(line)
except json.JSONDecodeError:
continue
if reply.get("id") == 1:
return reply.get("result") or {"error": reply.get("error")}
return {"error": f"no probe reply (rc={proc.returncode}): {proc.stderr[-300:]}"}
def cu_helper_live_checks(ctx: "Ctx", arm: str) -> list[tuple[str, str, str]]:
"""Amendment 11 preflight: the helper's probe reports the pinned required flags, and the adapter, started
exactly as in a trial, lists exactly the pinned tools."""
out: list[tuple[str, str, str]] = []
pins = ca.load_pins().get("claude_cu_helper", {})
build = ca.CU_HELPER_BUILDS[arm]
try:
probe = cu_helper_probe(build.helper, build.launcher)
except Exception as error: # noqa: BLE001
probe = {"error": f"{type(error).__name__}: {error}"}
ctx.versions.setdefault("claude_cu_helper", {})["probe"] = probe
required = pins.get("probe_required") or ["skylight", "axTrusted"]
missing = [k for k in required if probe.get(k) is not True]
out.append(
(
f"{arm} helper probe: {', '.join(required)}",
"pass" if not missing else "fail",
json.dumps(probe)[:400] + (f" missing {missing}" if missing else ""),
)
)
try:
selected = next(a for a in ctx.arm_names if SOURCE_ARM.get(a, a) == arm)
path, _server = ctx.mcp[selected]
if selected in cxn.ARMS:
entry = cxn.server_entry(path, selected)
command, cargs, env = entry["command"], entry["args"], entry["env"]
else:
command, cargs, env = mcp_entry(path)
tools = sorted(mcp_list_tools(command, cargs, env))
want = sorted(pins.get("tools") or [])
out.append(
(
f"{arm} adapter lists the pinned tools",
"pass" if want and tools == want else "fail",
f"{tools}" + ("" if tools == want else f" pinned {want}"),
)
)
except Exception as error: # noqa: BLE001
out.append((f"{arm} adapter MCP server", "fail", f"{type(error).__name__}: {error}"))
return out
def cu_helper_row_identity(ctx: "Ctx") -> dict[str, Any]:
pin = ca.load_pins().get("claude_cu_helper", {})
seen = ctx.versions.get("claude_cu_helper") or {}
return {
"label": ca.CU_HELPER_LABEL,
"desktop_version": pin.get("desktop_version"),
"helper_sha256": seen.get("helper_sha256"),
"adapter_sha256": seen.get("adapter_sha256"),
"actions": ca.cu_helper_actions(),
"probe": {
k: v for k, v in (seen.get("probe") or {}).items() if isinstance(v, (bool, str, int))
},
}
def mcp_entry(config_path: Path) -> tuple[str, list[str], dict[str, str]]:
data = json.loads(config_path.read_text("utf-8"))
((name, entry),) = data["mcpServers"].items()
env = {"HOME": os.environ.get("HOME", ""), "PATH": ca.CLAUDE_PATH, **entry.get("env", {})}
return entry["command"], list(entry.get("args", [])), env
# ---------------------------------------------------------------- one attempt
def evaluate_probe(
task: pilot.Task, seed: int, paths: dict[str, Path], artifacts: Path, sentinel_log: Path
) -> dict[str, Any]:
"""Call the task's evaluate.py (interface from #59 plus the optional --sentinel and diagnostics)."""
assert task.probe_dir is not None
result = artifacts / "evaluator-result.json"
command = [
sys.executable,
str(task.probe_dir / "evaluate.py"),
"--seed",
str(seed),
"--state",
str(paths["state"]),
"--events",
str(paths["events"]),
"--result",
str(result),
"--sentinel",
str(sentinel_log),
]
completed = subprocess.run(command, capture_output=True, text=True, timeout=120)
(artifacts / "evaluator.stderr").write_text(completed.stderr[-4000:], "utf-8")
if not result.is_file():
return {"passed": False, "score": None, "error": "evaluator wrote no result"}
data = json.loads(result.read_text("utf-8"))
return {
"passed": bool(data.get("passed")),
"score": data.get("score"),
"checks": {
name: bool(check.get("passed")) if isinstance(check, dict) else check
for name, check in (
data.get("checks") or (data.get("detail") or {}).get("checks") or {}
).items()
},
"diagnostics": data.get("diagnostics"),
}
def _collect_linux_evidence(artifacts: Path, arm: str, failed: bool) -> None:
"""Best-effort Linux end-of-trial evidence; never raises."""
if desktop.detect_platform() != "linux":
return
errors: list[str] = []
def attempt(operation: str, action: Any) -> None:
try:
action()
except Exception as error: # noqa: BLE001
errors.append(f"{operation}: {type(error).__name__}")
attempt(
"screenshot",
lambda: desktop.capture_screenshot(
os.environ.get("DISPLAY", ""), artifacts / ("failure.png" if failed else "final.png")
),
)
logs = {"recorder": ca.RECORDER_STATE / "daemon.log"}
if arm in ca.CUA_BUILDS:
logs["driver"] = ca.CUA_BUILDS[arm].state / "daemon.log"
for name, log in logs.items():
attempt(
f"{name} log",
lambda name=name, log=log: log.is_file()
and shutil.copyfile(log, artifacts / f"{name}.log"),
)
if errors:
try:
(artifacts / "screenshot-error.txt").write_text("\n".join(errors))
except OSError:
pass
def trial_identity(ctx: Ctx, entry: dict[str, Any]) -> dict[str, Any]:
"""What a trial id measures in this run: its place in the schedule and its setup. Every row records these,
and a resumed run must assign the same values to every trial id it already has rows for."""
args, arm = ctx.args, entry["arm"]
task = ctx.tasks[entry["task"]]
spec = task_spec(task)
bench_v2 = bool(getattr(args, "bench_v2", False)) # Amendment 14
model, effort = args.model, args.effort
if arm in cxn.ARMS:
model, effort = cxn.MODEL, cxn.EFFORT
if arm in pia.ARMS:
model, effort = f"{pia.PROVIDER}/{pia.MODEL}", pia.THINKING
return {
"smoke": bool(args.smoke),
**{k: entry[k] for k in ("phase", "block", "run", "run_index", "arm", "task")},
**{
k: entry[k]
for k in ("order_index", "task_pos", "arm_slot", "first_arm", "schedule_seed")
},
"bench_version": v2.BENCH_VERSION if bench_v2 else 1,
"condition": getattr(args, "condition", "foreground") if bench_v2 else None, # Amendment 15
"model": model,
"effort": effort,
"max_turns": int(args.max_turns or spec.get("max_turns") or 30),
"timeout_s": int(args.timeout_s or spec.get("timeout_s") or task.timeout_s or 240),
}
# Options that change how a run is operated, not what a trial measures. Every other option must match the
# recorded argv on resume. The schedule options (arms, tasks, phases) are checked per row instead, so a schedule
# may grow. Driver paths may move; the driver's identity is in every row and in the preflight's pins.
OPERATIONAL_OPTIONS = {
*("command", "run_id", "runs_dir", "ledger", "ledger_who", "cutoff_utc", "budget_cap_usd"),
*("seven_day_stop", "disk_floor_gb", "ignore_hold", "no_model_preflight", "offline"),
*("allow_non_terminal", "allow_codex_arms", "allow_unknown_quota", "claude_bin"),
*("arms", "tasks", "only_arm", "only_task", "phase1_runs", "phase2_runs"),
*("cua_bin", "cua_skills", "pins", "build_dir", "codex_cu_mcp"),
}
def option_conflicts(ctx: Ctx) -> list[str]:
"""Measured options of this start that differ from the run's recorded argv."""
manifest = ctx.run_dir / "manifest.json"
if not manifest.exists():
return []
try:
recorded = vars(
build_parser().parse_args(json.loads(manifest.read_text("utf-8"))["argv"][1:])
)
except (SystemExit, KeyError, ValueError):
return ["recorded argv in manifest.json does not parse with this runner"]
now = vars(ctx.args)
return [
f"--{k.replace('_', '-')}: recorded {recorded.get(k)!r}, now {now.get(k)!r}"
for k in sorted(set(recorded) | set(now))
if k not in OPERATIONAL_OPTIONS and recorded.get(k) != now.get(k)
]
def resume_conflicts(ctx: Ctx) -> list[str]:
"""Recorded rows whose trial id this start would schedule or run differently, or not at all. Empty for a
new run."""
rows = core.load_rows(ctx.results_path)
if not rows:
return []
schedule = {e["trial_id"]: e for e in core.flat_entries(ctx.blocks())}
conflicts = option_conflicts(ctx)
builds: dict[
str, dict[str, str | None]
] = {} # the Cua Driver build each arm would run now, hashed once
def build_of(arm: str, row: dict[str, Any]) -> dict[str, str | None]:
if arm not in builds:
b = ca.CUA_BUILDS[arm]
builds[arm] = {
"cua_driver_sha256": ca.sha256_file(b.bin) if b.bin.is_file() else None,
"skills_tree_sha256": ca.sha256_tree(b.skills) if b.skills.is_dir() else None,
}
return {k: v for k, v in builds[arm].items() if row.get(k)} # what this row recorded
for row in rows:
entry = schedule.get(row.get("trial_id"))
if entry is None:
conflicts.append(f"{row.get('trial_id')}: recorded, not in this schedule")
continue
want = trial_identity(ctx, entry)
if row.get(
"bench_src_sha256"
): # the runner, probes and briefs; pack tasks are pinned by preflight
want["bench_src_sha256"] = ctx.versions["bench_src_sha256"]
source = SOURCE_ARM.get(entry["arm"], entry["arm"])
if row.get(
"cua_driver_sha256"
): # the build it ran, or the recorder's (as run_attempt records it)
want.update(build_of(source if source in ca.CUA_BUILDS else "cc-cua-driver", row))
conflicts += [ # a row without the key (older than these fields) cannot prove its slot: refused
f"{row['trial_id']} {k}: recorded {row.get(k)!r}, now {want[k]!r}"
for k in want
if k not in row or row[k] != want[k]
]
return sorted(set(conflicts))
def run_attempt(ctx: Ctx, entry: dict[str, Any], attempt: int) -> dict[str, Any]:
args = ctx.args
task = ctx.tasks[entry["task"]]
arm = entry["arm"]
spec = task_spec(task)
identity = trial_identity(ctx, entry)
timeout_s, max_turns = identity["timeout_s"], identity["max_turns"]
run_index = entry["run_index"]
seed = core.probe_seed(task.id, run_index)
system_prompt = ca.system_prompt_for(
SOURCE_ARM.get(arm, arm), browser=bool(spec.get("browser"))
)
bench_v2 = bool(getattr(args, "bench_v2", False)) # Amendment 14
sentinel_front = True if bench_v2 else bool(spec.get("sentinel_frontmost", True))
condition = getattr(args, "condition", "foreground") if bench_v2 else None # Amendment 15
# Per-build Cua Driver identity (Amendment 3); arm B rows keep the 0.34.0 values of the recorder build.
build_versions = (ctx.versions.get("builds") or {}).get(SOURCE_ARM.get(arm, arm)) or (
ctx.versions.get("builds") or {}
).get("cc-cua-driver", {})
trial_dir = ctx.run_dir / "trials" / entry["trial_id"] / f"a{attempt}"
shutil.rmtree(trial_dir, ignore_errors=True)
artifacts = trial_dir / "artifacts"
artifacts.mkdir(parents=True)
t0 = time.monotonic()
started_utc = datetime.now(timezone.utc).isoformat(timespec="seconds")
idle_start = pilot.hid_idle_seconds()
row: dict[str, Any] = {
"schema": SCHEMA,
"infra_pattern": None,
"platform": desktop.detect_platform(),
"trial_id": entry["trial_id"],
"attempt": attempt,
"final": False,
**identity,
"run_id": ctx.run_dir.name,
"task_group": task_spec(task).get("group", "probe"),
"ability": spec.get("ability"),
"dimension_tags": task.tags,
"category": spec.get("category"),
"seed": seed,
"started_utc": started_utc,
"idle_at_start_s": round(idle_start),
"idle_gate_relaxed": bool(args.idle_min and idle_start < args.idle_min),
"claude_version": ctx.versions.get("claude"),
"cua_driver_version": build_versions.get("cua_driver_version"),
"cua_driver_sha256": build_versions.get("cua_driver_sha256"),
"cua_driver_git_sha": build_versions.get("cua_driver_git_sha"),
"cua_driver_daemon_version": build_versions.get("cua_daemon_version"),
"skills_tree_sha256": build_versions.get("cua_skills_tree_sha256")
if pia.SOURCE_ARM.get(arm, arm) in ca.CUA_ARMS
else None,
"macos": ctx.versions.get("macos"),
"os_version": ctx.versions.get("os_version"),
"bench_repo_commit": ctx.versions.get("bench_repo_commit"),
"bench_src_sha256": ctx.versions.get("bench_src_sha256"),
"system_prompt_sha256": hashlib.sha256(system_prompt.encode()).hexdigest(),
"skill_in_prompt": bool(
getattr(ca.CUA_BUILDS.get(pia.SOURCE_ARM.get(arm, arm)), "skill_in_prompt", False)
),
"electron_named_bundles": spec.get("kind") == "cdb"
and os.environ.get("CDB_ELECTRON_SHARED") != "1",
"quota_five_hour_before": (ctx.quota or {}).get("five_hour"),
"quota_seven_day_before": (ctx.quota or {}).get("seven_day"),
# whether Chrome/Electron got the force-accessibility switch (no shipped arm sets it)
"force_accessibility": ca.force_accessibility(arm),
# Amendment 11: the helper arm's identity (Desktop version, helper and adapter hashes, offered actions)
"claude_cu_helper": cu_helper_row_identity(ctx)
if SOURCE_ARM.get(arm, arm) in ca.CU_HELPER_ARMS
else None,
# Amendment 20: the native Codex arm's identity (Codex CLI build, model, effort)
"codex_native": ctx.versions.get("codex_native") if arm in cxn.ARMS else None,
"pi": ctx.versions.get("pi") if arm in pia.ARMS else None,
}
sentinel = pilot.Sentinel(
Path(args.build_dir or HERE / "linux") / "BenchSentinel.app"
if (args.build_dir or desktop.detect_platform() == "linux") and not args.no_sentinel
else None,
artifacts / "sentinel.jsonl",
v2.sentinel_args(condition) if bench_v2 else None,
)
app_env = pilot.clean_app_env(trial_dir / "apphome")
lab: subprocess.Popen[bytes] | None = None
claude: dict[str, Any] = {
"returncode": None,
"timed_out": False,
"wall_s": 0.0,
"result_seen": False,
"elicitations": [],
}
summary: dict[str, Any] = {}
evaluation: dict[str, Any] = {"passed": False, "score": None}
failure: dict[str, Any] = {"kind": None}
note = ""
video_raw: Path | None = None
agent_started = agent_ended = t0
stderr_path = trial_dir / "claude.stderr"
stream_path = trial_dir / "claude-stream.tsv"
needs = list(spec.get("needs_apps", []))
cdb = cdb_adapter.CdbTask(spec, artifacts, seed=seed) if spec.get("kind") == "cdb" else None
running_at_end: dict[str, bool] = {}
peeks: list[str] = []
front_seen: list[str] = []
side_door: set[str] = set()
watcher: FrontWatcher | None = None
guard: v2.GuiOnlyGuard | None = None
pi_root: Path | None = None
gui_only: dict[str, Any] | None = None
try:
ctx.set_state(
state="setup", trial_id=entry["trial_id"], attempt=attempt, trial_started_mono=t0
)
kill_bench_apps()
reset_needs_apps(needs)
if desktop.detect_platform() == "macos":
subprocess.run(
["pbcopy"], input=b"", capture_output=True
) # no stale clipboard between trials
if arm in ca.CUA_ARMS:
ensure_agent_daemon(ctx, arm)
elif (
SOURCE_ARM.get(arm) in ca.CUA_ARMS
): # A23: Cua Driver under Codex uses that build's daemon
ensure_agent_daemon(ctx, SOURCE_ARM[arm])
if getattr(args, "park_pointer", False):
row["pointer_parked"] = (
None # set even when park_pointer raises, so the row shows the attempt
)
row["pointer_parked"] = park_pointer(ctx)
lab_app = Path(args.build_dir or HERE / "linux") / "BenchLab.app"
if cdb is not None:
cdb.reset()
brief, paths = cdb.brief(), {}
sentinel.start()
cdb.start_apps(
windows=lambda win: place_window(ctx, win),
force_accessibility=ca.force_accessibility(arm),
)
row["health"] = cdb.health_check() # raises: a harness error, re-run, never scored
if ca.force_accessibility(arm):
row["force_accessibility_apps"] = [
line.split(":", 1)[0]
for line in cdb.log
if line.endswith(ca.FORCE_ACCESSIBILITY_FLAG)
]
else:
brief, paths = pilot.prepare_probe(task, seed, trial_dir, lab_app)
sentinel.start()
lab = pilot.launch_lab(task, seed, paths, lab_app, app_env)
if desktop.detect_platform() == "linux":
desktop.capture_screenshot(os.environ["DISPLAY"], artifacts / "startup.png")
if sentinel_front:
sentinel.activate()
if condition == "background": # A15.2: the user window covers part of the target on purpose
row["lab_occlusion"] = {
"skipped": "background condition",
"user_window": v2.USER_WINDOW_FRAME,
}
elif cdb is None and getattr(args, "check_occlusion", True):
row["lab_occlusion"] = ensure_lab_unoccluded(ctx)
row["lab_unoccluded"] = row["lab_occlusion"].get("unoccluded")
cwd = ca.prepare_cwd(pia.SOURCE_ARM.get(arm, arm)) # a pi arm gets its source arm's skill
mcp_path, server = ctx.mcp[arm]
native = arm in cxn.MCP_ARMS
argv = (
cxn.argv()
if native
else pia.argv(system_prompt, pia.skill_dir(cwd))
if arm in pia.ARMS
else ca.claude_argv(
mcp_config=mcp_path,
server=server,
model=args.model,
max_turns=max_turns,
max_budget_usd=args.max_budget_usd,
tool_search=args.tool_search == "default",
effort=args.effort,
coding_tools=bool(spec.get("coding_tools")) and not bench_v2,
system_prompt=system_prompt,
)
)
prompt = (v2.brief_for(brief.strip(), condition) if bench_v2 else brief.strip()) + "\n"
if args.tell_budget:
prompt += f"\nYou have about {timeout_s // 60} minutes and at most {max_turns} turns.\n"
(artifacts / "prompt.txt").write_text(prompt, "utf-8")
(artifacts / "argv.json").write_text(json.dumps(argv, indent=2) + "\n", "utf-8")
recording = ctx.recorder.start(trial_dir / "rec") if ctx.recorder else False
row["recording_started"] = bool(recording)
sentinel.toggle_armed()
ctx.set_state(state="agent")
agent_started = time.monotonic()
if bench_v2: # A14.2: every v2 trial is guarded, CDB or BenchLab
guard = v2.GuiOnlyGuard(
stream_path,
frontmost_bundle,
enforce=getattr(args, "gui_only_enforce", True),
terminal_ttys=v2.terminal_tty_inputs, # A19: shell input in a background Terminal
)
guard.start()
watcher = (
FrontWatcher()
if not bench_v2 and not spec.get("coding_tools") and cdb is not None
else None
)
if watcher:
watcher.start()
with pilot.IdleSampler(artifacts / "hid-idle.jsonl"):
if (
native
): # Amendment 20: codex exec, its stream translated for the guard and the summaries
claude = cxn.run_codex(
argv,
cxn.render_home(
trial_dir / "codex-home",
mcp_path,
cxn.MODEL,
cxn.EFFORT,
system_prompt,
arm,
),
cwd,
prompt,
timeout_s,
max_turns,
trial_dir / "codex-app-server.tsv",
stream_path,
stderr_path,
allowed_apps=allowed_apps(task),
elicitation_path=artifacts / "elicitations.jsonl",
abort=v2.EitherEvent(ctx.abort, guard.stop) if guard else ctx.abort,
server=cxn.SERVER_OF[arm],
)
elif arm in pia.ARMS:
pi_root = pia.new_root()
claude = pia.run_pi(
argv,
pia.render_agent_dir(pi_root, mcp_path, pia.skill_dir(cwd), max_turns),
cwd,
prompt,
timeout_s,
max_turns,
trial_dir / "pi-events.tsv",
stream_path,
stderr_path,
abort=v2.EitherEvent(ctx.abort, guard.stop) if guard else ctx.abort,
)
else:
claude = claude_driver.run_claude(
argv,
ca.claude_env(),
cwd,
prompt,
allowed_apps(task),
timeout_s,
stream_path,
stderr_path,
artifacts / "elicitations.jsonl",
abort=v2.EitherEvent(ctx.abort, guard.stop) if guard else ctx.abort,
)
agent_ended = time.monotonic()
if watcher:
watcher.finish()
front_seen, side_door = sorted(watcher.seen), set(watcher.side)
if guard:
guard.finish()
running_at_end = apps_running(needs)
sentinel.toggle_armed()
ctx.set_state(state="teardown")
video_raw = ctx.recorder.stop() if ctx.recorder and recording else None
events = claude_events.read_events(stream_path)
summary = claude_events.summarize(events)
if native: # turns are sampling requests (thread/tokenUsage/updated), not tool uses
summary["turns"] = summary["api_calls"] = claude.get("turns")
row["codex_usage"] = claude.get("codex_usage")
row["codex_non_gui_items"] = claude.get("non_gui_items")
stderr_text = (
stderr_path.read_text("utf-8", "replace")[-4000:] if stderr_path.exists() else ""
)
failure = claude_events.classify_failure(summary, stderr_text, claude["returncode"])
if guard:
gui_only = guard.summary(*v2.scan_events(events))
front_seen = gui_only["frontmost_seen"]
side_door = {v["detail"] for v in gui_only["violations"]}
if gui_only["stopped_trial"]:
failure = {"kind": None} # the harness ended it on purpose: final, never retried
try:
if cdb is not None:
rc = claude.get("returncode")
evaluation = cdb.evaluate(124 if rc is None else int(rc))
snapshot_workspace(cdb.workspace, artifacts / "workspace-final.tgz")
peeks = evaluator_peeks(events, spec.get("peek_patterns", []))
if not spec.get("coding_tools"):
side_door |= set(side_door_scan(events))
else:
evaluation = evaluate_probe(
task, seed, paths, artifacts, artifacts / "sentinel.jsonl"
)
except Exception as error: # noqa: BLE001 - an evaluator crash is a failed trial, recorded
evaluation = {
"passed": False,
"score": None,
"error": f"{type(error).__name__}: {error}",
}
if evaluation.get("harness_error") and not failure.get("kind"):
# no export or no evaluator result: the harness failed, not the agent; re-run, never scored
failure = {
"kind": "harness_evaluator",
"message": f"{evaluation['harness_error']}: {evaluation.get('error', '')}",
}
except StopRun:
raise
except Exception as error: # noqa: BLE001 - record, classify as harness exception, never crash the matrix
failure = {"kind": "harness_exception", "message": f"{type(error).__name__}: {error}"}
note = failure["message"]
finally:
try:
_collect_linux_evidence(
artifacts, pia.SOURCE_ARM.get(arm, arm), bool(failure.get("kind"))
)
finally:
if pi_root is not None:
pia.keep_config(pi_root, trial_dir / "pi-agent")
codex_home = trial_dir / "codex-home" / ".codex"
if arm in cxn.ARMS and codex_home.is_dir():
try:
arms.unlink_chatgpt_auth(codex_home)
except RuntimeError as error:
failure = {"kind": "harness_exception", "message": str(error)}
note = str(error)
try:
sentinel.stop()
except Exception: # noqa: BLE001
pass
if ctx.recorder and video_raw is None and row.get("recording_started"):
video_raw = ctx.recorder.stop()
if lab is not None:
claude_driver.kill_group(lab.pid)
lab.wait(timeout=5)
if watcher is not None:
watcher.finish()
if guard is not None:
guard.finish()
if cdb is not None:
cdb.stop_apps()
pilot.sweep_processes(str(trial_dir))
helper_arm = SOURCE_ARM.get(arm, arm) # A23: the helper under Codex CLI uses the same build
if helper_arm in ca.CU_HELPER_ARMS:
# the adapter and its helper end with claude's process group; a survivor could post input later
row["cu_helper_leftover_killed"] = pilot.sweep_processes(
str(ca.CU_HELPER_BUILDS[helper_arm].helper)
) + (pilot.sweep_processes(str(ca.CU_HELPER_BUILDS[helper_arm].adapter)))
kill_bench_apps()
reset_needs_apps(needs)
saved = strip_stream_file(stream_path)
# --- bookkeeping
quota_after = merge_quota(ctx.quota, summary.get("quota_last"))
ctx.quota = quota_after
note_quota(ctx, summary.get("quota_last"), f"trial {entry['trial_id']}")
tokens = summary.get("tokens", {"input": 0, "output": 0, "cache_read": 0, "cache_write": 0})
cost = summary.get("total_cost_usd")
cost_source = "result.total_cost_usd"
if entry["arm"] in cxn.ARMS:
cost, cost_source = (
None,
"not priced (Codex subscription; tokens reported)",
)
elif entry["arm"] in pia.ARMS:
cost_source = pia.COST_SOURCE
elif cost is None:
cost = estimate_cost(tokens)
cost_source = "estimated_from_tokens (no result event)"
result = summary.get("result", {})
final_text = summary.get("final_text", "")
summary_sentinel = sentinel.summary()
hid = summary_sentinel.get("hid_events", {}) if sentinel.enabled else {}
hid_total = sum(int(v) for v in hid.values()) if hid else 0
deviation = float(summary_sentinel.get("pointer_max_deviation_px", 0.0) or 0.0)
infra = failure.get("kind")
violation = bool(gui_only and gui_only["violation"])
if gui_only and gui_only["stopped_trial"]:
status = "gui_only_violation"
elif claude.get("timed_out"):
status = "timeout"
elif infra:
status = "infra_error"
elif result.get("subtype") == "error_max_turns":
status = "max_turns"
elif result.get("is_error") or not claude.get("result_seen"):
status = "agent_error"
else:
status = "completed"
# a rate-limit or overload that cut a trial short is an infrastructure failure only when the
# agent had not already finished; the classifier looks at the result event, so trust it.
row.update(
{
"ended_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"),
"status": status,
"infra_failure": infra,
"infra_message": failure.get("message", "")[:300] if infra else "",
"infra_pattern": failure.get("pattern") if infra else None,
"infra_reset_epoch": failure.get("reset_epoch") if infra else None,
"excluded": bool(infra),
"excluded_reason": f"infra_failure:{infra}" if infra else None,
"passed": bool(evaluation.get("passed"))
and status in ("completed", "timeout", "max_turns", "agent_error")
and not infra
and not violation, # A14.2: a GUI-only violation fails the trial
"passed_raw": bool(evaluation.get("passed")) and not infra,
"score": evaluation.get("score"),
"checks": evaluation.get("checks"),
"diagnostics": evaluation.get("diagnostics"),
"evaluator_error": evaluation.get("error"),
"declared": (
"DONE"
if final_text.strip().upper().startswith("DONE")
else "BLOCKED"
if final_text.strip().upper().startswith("BLOCKED")
else "other"
)
if final_text
else "none",
"final_text": final_text[:500],
"wall_s": round(time.monotonic() - t0, 2),
"agent_wall_s": claude.get("wall_s"),
"overhead_s": round((time.monotonic() - t0) - (claude.get("wall_s") or 0.0), 2),
"turns": summary.get("turns"),
"num_turns_result": result.get("num_turns"),
"tool_calls": summary.get(
"tool_calls", {"total": 0, "by_class": {}, "by_name": {}, "failed": 0}
),
"steps": (summary.get("tool_calls") or {}).get("total", 0),
"action_latency_ms": summary.get("action_latency_ms", {}),
"tokens": {
"input": tokens.get("input", 0),
"output": tokens.get("output", 0),
"cache_read": tokens.get("cache_read", 0),
"cache_write": tokens.get("cache_write", 0),
"cached_input": tokens.get("cache_read", 0),
"reasoning": 0,
},
"token_source": summary.get("token_source"),
"baseline_prompt_tokens": summary.get("baseline_prompt_tokens"),
"cost_usd": cost,
"est_cost_usd": cost,
"cost_source": cost_source,
"duration_ms": result.get("duration_ms"),
"duration_api_ms": result.get("duration_api_ms"),
"stop_reason": result.get("stop_reason"),
"terminal_reason": result.get("terminal_reason"),
"result_subtype": result.get("subtype"),
"api_error_status": result.get("api_error_status"),
"permission_denials": result.get("permission_denials"),
"returncode": claude.get("returncode"),
"timed_out": claude.get("timed_out"),
"elicitations": [
{"answer": e.get("answer"), "message": e.get("message", "")[:80]}
for e in claude.get("elicitations", [])
if "message" in e
],
"unhandled_requests": [e for e in claude.get("elicitations", []) if "unhandled" in e],
"init": summary.get("init"),
"mcp_deferred_inferred": bool(summary.get("init", {}).get("tool_search_available"))
and (summary.get("baseline_prompt_tokens") or 0) < 25000
and (summary.get("init", {}).get("mcp_tool_count", 0) > 20),
"tool_search_calls": (summary.get("tool_calls", {}).get("by_name", {}) or {}).get(
"ToolSearch", 0
),
"quota_five_hour_after": (quota_after or {}).get("five_hour"),
"quota_seven_day_after": (quota_after or {}).get("seven_day"),
"quota_status": (quota_after or {}).get("status"),
"disturbance": {
"available": bool(summary_sentinel.get("available")),
"front_changes": summary_sentinel.get("front_changes", 0),
"front_changed_to": summary_sentinel.get("front_changed_to", []),
"key_loss": summary_sentinel.get("key_loss", 0),
"keystrokes_leaked": summary_sentinel.get("keystrokes_leaked", 0),
"clicks_leaked": summary_sentinel.get("clicks_leaked", 0),
"scrolls_leaked": summary_sentinel.get("scrolls_leaked", 0),
"pointer_max_deviation_px": deviation,
"pointer_deviation_episodes": summary_sentinel.get("pointer_deviation_episodes", 0),
"pointer_moved": deviation > pilot_deviation_px(),
"frontmost_changed": bool(summary_sentinel.get("front_changes", 0)),
"hid_events": (hid or {"move": 0, "down": 0, "key": 0, "scroll": 0})
if desktop.detect_platform() == "macos"
else None,
"human_input_suspected": bool(hid_total and idle_start < 900)
if desktop.detect_platform() == "macos"
else None,
"windows_raised": summary_sentinel.get("windows_raised"),
"raised_by": summary_sentinel.get("raised_by", []),
"overlay_owners": summary_sentinel.get("overlay_owners", []),
"user_activity": summary_sentinel.get("user_activity"),
# Amendment 22: the remaining multi-player measures (None when the sentinel did not record them)
"activations_lost": summary_sentinel.get("activations_lost"),
"activations_gained": summary_sentinel.get("activations_gained"),
"clipboard_changes": summary_sentinel.get("clipboard_changes"),
"space_switches": summary_sentinel.get("space_switches"),
"sheets_shown": summary_sentinel.get("sheets_shown"),
},
"sentinel_frontmost": sentinel_front,
"gui_only": gui_only,
"interruption": v2.interruption_of(evaluation),
"hid_idle_drops": pilot.hid_drops(artifacts / "hid-idle.jsonl")
if desktop.detect_platform() == "macos" and (artifacts / "hid-idle.jsonl").exists()
else None,
"confirmation_requested": False,
"evaluator_read_suspected": bool(peeks),
"evaluator_peeks": peeks,
"frontmost_seen": front_seen,
"side_door": sorted(side_door),
"side_door_flag": bool(side_door),
"recorder": getattr(ctx.recorder, "name", "none"),
"video": str(trial_dir / "video" / "video.mp4") if video_raw else None,
"video_720p": str(trial_dir / "video" / "video-720p.mp4") if video_raw else None,
"needs_apps_running_at_end": running_at_end,
"stream_bytes_saved": saved,
"notes": note,
}
)
# A14.4: the background-operation score, on every v2 trial
row["background"] = (
v2.background_score(row["disturbance"], sentinel_front) if bench_v2 else None
)
row["background_condition"] = (
v2.background_condition_score(
row["background"], row["disturbance"], bool(row["passed"]), condition
)
if bench_v2
else None
)
# A22: the headline background metric, multi-player background completion, with each criterion on its own
row["multiplayer"] = (
v2.multiplayer_score(
row["disturbance"], bool(row["background"]["measured"]), bool(row["passed"]), condition
)
if bench_v2
else None
)
if video_raw and ctx.compress:
ctx.compress.submit(video_raw, trial_dir / "video")
(trial_dir / "trial.json").write_text(json.dumps(row, indent=2) + "\n", "utf-8")
for name in ("apphome",):
shutil.rmtree(trial_dir / name, ignore_errors=True)
return row
def snapshot_workspace(workspace: Path, dest: Path) -> None:
"""Small tarball of the final workspace (no browser profile, no node_modules) for the audit trail."""
subprocess.run(
[
"tar",
"-czf",
str(dest),
"--exclude",
".chromium-profile",
"--exclude",
"node_modules",
"--exclude",
".runtime",
"-C",
str(workspace.parent),
workspace.name,
],
capture_output=True,
timeout=120,
)
DEFAULT_PEEK_PATTERNS = (
"evaluator",
"oracle",
"hidden_test",
"taskpack",
"bench-work",
"cdbeval",
"cdb-eval",
".cdb-secrets",
"/__state",
)
def evaluator_peeks(events: list[dict[str, Any]], patterns: list[str]) -> list[str]:
"""Tool calls whose input names evaluator material or the task pack (the pack sits on the same
disk as the agent; this is the control, see TASKS.md). Returns 'Tool:pattern' strings."""
found: list[str] = []
pats = list(patterns) or list(DEFAULT_PEEK_PATTERNS)
for event in events:
if event.get("type") != "assistant":
continue
for block in (event.get("message") or {}).get("content") or []:
if isinstance(block, dict) and block.get("type") == "tool_use":
text = json.dumps(block.get("input", {}))
for pat in pats:
if pat in text:
found.append(f"{block.get('name')}:{pat}")
return found[:20]
def place_window(ctx: "Ctx", win: dict[str, Any], wait_s: float = 90.0) -> bool:
"""Wait for a window by title, then move and size it, through the recorder daemon.
Returns False when the window never appeared (LibreOffice needs a while on a cold start)."""
needle = win.get("title") or win.get("title_contains")
bounds = win.get("bounds")
if not needle or not bounds:
return True
rec_home = ca.RECORDER_STATE / "home"
deadline = time.monotonic() + wait_s
while time.monotonic() < deadline:
done = ca.cua_cli(
"call", "list_windows", "{}", socket=ca.RECORDER_SOCKET, home=rec_home, timeout=20
)
try:
data = json.loads(done.stdout[done.stdout.index("{") :])
except (ValueError, json.JSONDecodeError):
time.sleep(0.5)
continue
for item in _walk_dicts(data):
title = str(item.get("title") or item.get("window_title") or "")
wid = item.get("window_id", item.get("id"))
pid = item.get("pid", item.get("owner_pid"))
if needle.lower() in title.lower() and wid is not None and pid is not None:
args = {
"pid": pid,
"window_id": wid,
"x": bounds["x"],
"y": bounds["y"],
"width": bounds["width"],
"height": bounds["height"],
}
ca.cua_cli(
"call",
"set_window_frame",
json.dumps(args),
socket=ca.RECORDER_SOCKET,
home=rec_home,
timeout=20,
)
return True
time.sleep(0.5)
return False
LAB_APP_NAME = "BenchLab"
LAB_CLEAR_X = 840 # Amendment 4 (A4.8): x where an occluding window is moved, right of BenchLab's 60..820 frame
def _overlap(a: dict[str, Any], b: dict[str, Any]) -> bool:
return (
a["x"] < b["x"] + b["width"]
and b["x"] < a["x"] + a["width"]
and a["y"] < b["y"] + b["height"]
and b["y"] < a["y"] + a["height"]
)
def lab_occluders(
windows: list[dict[str, Any]],
) -> tuple[dict[str, Any] | None, list[dict[str, Any]]]:
"""BenchLab's frontmost on-screen window and every normal-layer window above it that overlaps it.
Cua Driver's macOS ``z_index`` grows towards the front."""
normal = [
w
for w in windows
if isinstance(w.get("bounds"), dict)
and w.get("z_index") is not None
and w.get("is_on_screen", True)
and (w.get("layer") or 0) == 0
]
labs = [w for w in normal if w.get("app_name") == LAB_APP_NAME]
if not labs:
return None, []
lab = max(labs, key=lambda w: w["z_index"])
above = [
w
for w in normal
if w.get("app_name") != LAB_APP_NAME
and w["z_index"] > lab["z_index"]
and _overlap(w["bounds"], lab["bounds"])
]
return lab, above
def _brief(w: dict[str, Any]) -> dict[str, Any]:
return {k: w.get(k) for k in ("app_name", "title", "pid", "window_id", "z_index", "bounds")}
def ensure_lab_unoccluded(ctx: "Ctx") -> dict[str, Any]:
"""Amendment 4 (A4.8, CUA-1219): before a BenchLab probe, record the window stack over BenchLab and move any
other app's window that overlaps it to the right of it, through the recorder daemon, then check again.
BenchSentinel is moved like any other window. Returns the record stored in the row."""
rec_home = ca.RECORDER_STATE / "home"
def read() -> list[dict[str, Any]]:
done = ca.cua_cli(
"call", "list_windows", "{}", socket=ca.RECORDER_SOCKET, home=rec_home, timeout=20
)
data = json.loads(done.stdout[done.stdout.index("{") :])
return [w for w in _walk_dicts(data) if "window_id" in w and "bounds" in w]
try:
lab, above = lab_occluders(read())
record: dict[str, Any] = {
"lab": _brief(lab) if lab else None,
"occluders_at_start": [_brief(w) for w in above],
"moved": [],
}
for w in above:
b = w["bounds"]
args = {
"pid": w.get("pid"),
"window_id": w["window_id"],
"x": LAB_CLEAR_X,
"y": b["y"],
"width": b["width"],
"height": b["height"],
}
ca.cua_cli(
"call",
"set_window_frame",
json.dumps(args),
socket=ca.RECORDER_SOCKET,
home=rec_home,
timeout=20,
)
record["moved"].append(_brief(w))
if above:
time.sleep(0.5)
lab, above = lab_occluders(read())
record["occluders_after"] = [_brief(w) for w in above]
record["unoccluded"] = lab is not None and not above
return record
except (OSError, ValueError, KeyError, subprocess.TimeoutExpired) as error:
return {"error": f"{type(error).__name__}: {error}", "unoccluded": None}
PARK_POINT = v2.PARK_POINT # Amendment 24: fixed, outside every registered window frame
class ParkFailed(RuntimeError):
"""The pointer could not be parked and verified; the trial setup fails (a harness error, never scored)."""
def _xy_of(node: Any) -> tuple[float, float] | None:
for item in _walk_dicts(node):
x, y = item.get("x"), item.get("y")
if isinstance(x, (int, float)) and isinstance(y, (int, float)):
return float(x), float(y)
return None
def park_pointer(ctx: "Ctx") -> dict[str, Any]:
"""Move the real pointer to PARK_POINT before each trial, read the position back and return the record for
the trial row. macOS: through the recorder daemon. Linux X11: xdotool. Raises ParkFailed when the pointer
does not land within tolerance, or when the platform has no supported way to do it (no faking)."""
clash = v2.park_point_clear(PARK_POINT)
if clash:
raise ParkFailed(f"park point {PARK_POINT} lies inside registered frame(s) {clash}")
platform_name = desktop.detect_platform()
try:
if platform_name == "macos":
rec_home = ca.RECORDER_STATE / "home"
args = {"x": PARK_POINT[0], "y": PARK_POINT[1], "scope": "desktop"}
ca.cua_cli(
"call",
"move_cursor",
json.dumps(args),
socket=ca.RECORDER_SOCKET,
home=rec_home,
timeout=20,
)
done = ca.cua_cli(
"call",
"get_cursor_position",
"{}",
socket=ca.RECORDER_SOCKET,
home=rec_home,
timeout=20,
)
read_back = _xy_of(json.loads(done.stdout[done.stdout.index("{") :]))
record = v2.park_record(read_back, "recorder-daemon move_cursor")
elif platform_name == "linux" and shutil.which("xdotool") and os.environ.get("DISPLAY"):
subprocess.run(
["xdotool", "mousemove", str(PARK_POINT[0]), str(PARK_POINT[1])],
check=True,
timeout=20,
)
out = subprocess.run(
["xdotool", "getmouselocation", "--shell"],
check=True,
capture_output=True,
text=True,
timeout=20,
).stdout
found = dict(line.split("=", 1) for line in out.split() if "=" in line)
read_back = (float(found["X"]), float(found["Y"]))
record = v2.park_record(read_back, "xdotool mousemove")
else:
raise ParkFailed(
f"no supported way to park the pointer on {platform_name} without X11 xdotool"
)
except ParkFailed:
raise
except (OSError, ValueError, KeyError, subprocess.SubprocessError) as error:
raise ParkFailed(f"{type(error).__name__}: {error}") from error
if not record["ok"]:
raise ParkFailed(f"pointer read back at {record['read_back']}, expected {list(PARK_POINT)}")
return record
def _walk_dicts(node: Any):
if isinstance(node, dict):
yield node
for value in node.values():
yield from _walk_dicts(value)
elif isinstance(node, list):
for value in node:
yield from _walk_dicts(value)
SIDE_DOOR_BUNDLES = v2.SIDE_DOOR_BUNDLES
SIDE_DOOR_PROCESSES = v2.SIDE_DOOR_PROCESSES
SIDE_DOOR_PATTERNS = (
"Terminal",
"iTerm",
"Script Editor",
"ScriptEditor",
"Automator",
"Shortcuts",
"osascript",
"child_process",
"execSync",
"spawnSync",
"/bin/sh",
"/bin/zsh",
"/bin/bash",
"bash -c",
"zsh -c",
"subprocess",
"os.system",
)
def frontmost_bundle() -> str | None:
"""Bundle id of the frontmost app through lsappinfo (no TCC permission needed)."""
if desktop.detect_platform() == "linux":
try:
window = subprocess.check_output(
["xdotool", "getactivewindow"], text=True, timeout=3
).strip()
props = subprocess.check_output(
["xprop", "-id", window, "WM_CLASS"], text=True, timeout=3
)
names = re.findall(r'"([^\"]+)"', props)
if not names:
return None
return next(
(name for name in v2.LINUX_TERMINALS if name.casefold() == names[-1].casefold()),
names[-1],
)
except (OSError, subprocess.SubprocessError):
return None
try:
asn = subprocess.run(
["/usr/bin/lsappinfo", "front"], capture_output=True, text=True, timeout=3
).stdout.strip()
if not asn:
return None
out = subprocess.run(
["/usr/bin/lsappinfo", "info", "-only", "bundleid", asn],
capture_output=True,
text=True,
timeout=3,
).stdout
match = re.search(r'"([A-Za-z0-9._-]+)"\s*$', out.strip())
return match.group(1) if match else None
except (OSError, subprocess.TimeoutExpired):
return None
class FrontWatcher(threading.Thread):
"""Samples the frontmost app and the side-door processes during the agent phase (GUI-only tasks)."""
def __init__(self, interval: float = 0.5) -> None:
super().__init__(daemon=True)
self.interval = interval
self.stop_event = threading.Event()
self.seen: set[str] = set()
self.side: set[str] = set()
def run(self) -> None:
while not self.stop_event.is_set():
bundle = frontmost_bundle()
if bundle:
self.seen.add(bundle)
if bundle in SIDE_DOOR_BUNDLES:
self.side.add(f"front:{SIDE_DOOR_BUNDLES[bundle]}")
for name in SIDE_DOOR_PROCESSES:
if subprocess.run(["pgrep", "-x", name], capture_output=True).returncode == 0:
self.side.add(f"process:{name}")
self.stop_event.wait(self.interval)
def finish(self) -> None:
self.stop_event.set()
self.join(timeout=5)
def side_door_scan(events: list[dict[str, Any]]) -> list[str]:
"""GUI-only trials: tool inputs that name a terminal, a scripting app or a shell escape."""
found: list[str] = []
for event in events:
if event.get("type") != "assistant":
continue
for block in (event.get("message") or {}).get("content") or []:
if isinstance(block, dict) and block.get("type") == "tool_use":
text = json.dumps(block.get("input", {}))
for pat in SIDE_DOOR_PATTERNS:
if pat in text:
found.append(f"{block.get('name')}:{pat}")
return sorted(set(found))[:20]
def kill_bench_apps() -> None:
"""Exact process names only (a command-line match once killed a compiler)."""
for name in ("BenchLab", "BenchSentinel"):
subprocess.run(["pkill", "-x", name], capture_output=True)
time.sleep(0.3)
SAVED_STATE = {
"Calculator": [
Path.home() / "Library/Saved Application State/com.apple.calculator.savedState",
Path.home()
/ "Library/Containers/com.apple.calculator/Data/Library/Saved Application State/com.apple.calculator.savedState",
],
}
def reset_needs_apps(names: list[str]) -> None:
"""Kill the apps a task needs and remove their saved window state so each trial starts clean."""
if desktop.detect_platform() == "linux":
return
for name in names:
subprocess.run(["pkill", "-x", name], capture_output=True)
time.sleep(0.3)
for name in names:
for path in SAVED_STATE.get(name, []):
shutil.rmtree(path, ignore_errors=True)
def apps_running(names: list[str]) -> dict[str, bool]:
return {
n: subprocess.run(["pgrep", "-x", n], capture_output=True).returncode == 0 for n in names
}
def pilot_deviation_px() -> float:
import summarize_sentinel # type: ignore
return float(getattr(summarize_sentinel, "DEVIATION_PX", 10.0))
# ---------------------------------------------------------------- one trial with retries
def append_row(ctx: Ctx, row: dict[str, Any]) -> None:
core.append_row(ctx.results_path, row)
cost = row.get("cost_usd") or 0.0
ctx.ledger.append(
ctx.args.ledger_who,
f"{'smoke ' if row.get('smoke') else ''}trial {row['trial_id']} a{row['attempt']}",
row.get("model") or ctx.args.model,
cost,
run_id=ctx.run_dir.name,
status=row.get("status"),
seven_day_after=row.get("quota_seven_day_after"),
)
with ctx.lock:
ctx.state["spend_run"] = ctx.state.get("spend_run", 0.0) + cost
def check_gates(ctx: Ctx) -> None:
"""Raise StopRun, or wait, before a new attempt may start."""
args = ctx.args
while True:
if (ctx.run_dir / "STOP").exists():
raise StopRun("USER", "STOP file")
if core.past_cutoff(ctx.cutoff):
raise StopRun("TIME", "cutoff reached")
if not core.budget_allows(
ctx.ledger.cumulative(), args.max_budget_usd, args.budget_cap_usd
):
raise StopRun("BUDGET", f"cap {args.budget_cap_usd}")
free = rec.free_gb(ctx.run_dir)
if free < args.disk_floor_gb:
if ctx.compress and ctx.compress.pending():
ctx.log(f"disk {free:.1f} GB < floor; waiting for compression")
ctx.compress.join()
continue
raise StopRun("DISK", f"{free:.1f} GB free")
gate = core.quota_gate(ctx.quota, args.seven_day_stop)
if gate["action"] == "stop":
raise StopRun("QUOTA", gate["reason"])
if gate["action"] == "wait":
wait_until = gate.get("wait_until")
seconds = core.wait_seconds(0, wait_until)
if wait_until and core.past_cutoff(ctx.cutoff, time.time() + seconds):
raise StopRun("TIME", "quota reset is after the cutoff")
log_pause(ctx, "quota_wait", seconds, gate["reason"], ctx.state.get("trial_id"))
ctx.quota = dict(ctx.quota or {}, status="allowed_after_wait", five_hour=None)
continue
return
def execute_trial(ctx: Ctx, entry: dict[str, Any]) -> dict[str, Any]:
# A resumed trial continues after its recorded attempts and keeps their retry budgets. An attempt that died
# before its row was written has no number yet, so its directory is reused and redone.
attempt, kinds = core.prior_attempts(core.load_rows(ctx.results_path), entry["trial_id"])
rate_waits = kinds.count("rate_limit")
overload_tries = kinds.count("overloaded")
infra_tries = len(kinds) - rate_waits - overload_tries
while True:
check_gates(ctx)
attempt += 1
ctx.log(f"trial {entry['trial_id']} attempt {attempt} start")
row = run_attempt(ctx, entry, attempt)
kind = row.get("infra_failure")
row["final"] = not kind
decision = "final"
wait_s = 0.0
if kind == "rate_limit":
gate = core.quota_gate(ctx.quota, ctx.args.seven_day_stop)
if gate["action"] == "stop":
row["final"] = False
row.pop("_quota_events", None)
append_row(ctx, row)
raise StopRun("QUOTA", gate["reason"])
reset = row.get("infra_reset_epoch") or (
gate.get("wait_until") if gate["action"] == "wait" else None
)
decision, wait_s = "retry", core.wait_seconds(rate_waits, reset)
rate_waits += 1
elif kind == "overloaded":
if overload_tries < core.OVERLOAD_RETRIES:
decision, wait_s = "retry", core.backoff_seconds(overload_tries)
overload_tries += 1
else:
row["final"] = True
decision = "exclude"
elif kind == "auth":
if infra_tries < 1:
decision, wait_s = "retry", 30.0
infra_tries += 1
else:
row["final"] = True
append_row(ctx, row)
raise StopRun("AUTH", row.get("infra_message", ""))
elif kind:
if infra_tries < 1:
decision, wait_s = "retry", 5.0
infra_tries += 1
else:
row["final"] = True
decision = "exclude"
row.pop("_quota_events", None)
append_row(ctx, row)
ctx.log(
f"trial {entry['trial_id']} a{attempt}: {row['status']} passed={row['passed']} infra={kind} "
f"wall={row['wall_s']}s turns={row.get('turns')} cost=${row['cost_usd'] or 0:.3f} 7d={row.get('quota_seven_day_after')}"
)
if decision in ("final", "exclude"):
ctx.set_state(
state="idle",
trials_done=ctx.state.get("trials_done", 0) + 1,
trial_started_mono=None,
)
return row
if (
kind in ("mcp_start", "tool_setup")
and SOURCE_ARM.get(entry["arm"], entry["arm"]) in ca.CUA_ARMS
):
try:
ensure_agent_daemon(ctx, SOURCE_ARM.get(entry["arm"], entry["arm"]))
except Exception as error: # noqa: BLE001
ctx.log(f"daemon restart failed: {error}")
log_pause(ctx, f"retry_{kind}", wait_s, row.get("infra_message", ""), entry["trial_id"])
# ---------------------------------------------------------------- preflight
def quota_probe(ctx: Ctx) -> tuple[bool, str]:
"""One tiny haiku call (no MCP, no tools) to read the subscription utilisation."""
argv = [
str(ca.CLAUDE_BIN),
"-p",
"--model",
"claude-haiku-4-5",
"--system-prompt",
"Reply with the word OK.",
"--output-format",
"stream-json",
"--verbose",
"--no-session-persistence",
"--tools",
"",
"--strict-mcp-config",
"--setting-sources",
"project",
"--max-turns",
"1",
"Reply OK",
]
cwd = ca.prepare_cwd("cc-codex-cu", ca.CWD_ROOT)
env = ca.claude_env()
token_fd = ca.open_token_fd()
if token_fd is not None:
env["CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR"] = str(token_fd)
try:
done = subprocess.run(
argv,
cwd=str(cwd),
env=env,
capture_output=True,
text=True,
timeout=120,
stdin=subprocess.DEVNULL,
pass_fds=(token_fd,) if token_fd is not None else (),
)
finally:
if token_fd is not None:
os.close(token_fd)
events = []
for line in done.stdout.splitlines():
try:
events.append(json.loads(line))
except json.JSONDecodeError:
pass
summary = claude_events.summarize(events)
ctx.ledger.append(
ctx.args.ledger_who, "quota probe", "claude-haiku-4-5", summary.get("total_cost_usd")
)
ctx.quota = merge_quota(ctx.quota, summary.get("quota_last"))
note_quota(ctx, summary.get("quota_last"), "quota probe")
if not summary.get("quota_last"):
return False, "no rate_limit_event in the stream; utilisation unknown"
q = ctx.quota or {}
return (
True,
f"five_hour={q.get('five_hour')} seven_day={q.get('seven_day')} status={q.get('status')} resets_5h={q.get('five_hour_resets_at')} resets_7d={q.get('seven_day_resets_at')}",
)
def native_codex_checks(ctx: Ctx, arm: str, with_models: bool) -> list[tuple[str, str, str]]:
"""Check CLI pins and authentication; only gateway mode optionally makes a model call."""
out: list[tuple[str, str, str]] = []
observed = ctx.versions.get("codex_native") or cxn.observed()
want = ca.load_pins().get("codex_native") or {}
for key in ("codex_cli_version", "codex_cli_sha256"):
ok = bool(want.get(key)) and observed.get(key) == want.get(key)
out.append(
(
f"pin codex_native.{key}",
"pass" if ok else ("warn" if ctx.args.smoke else "fail"),
str(observed.get(key))
if ok
else f"observed {observed.get(key)!r}, pinned {want.get(key)!r}",
)
)
chatgpt = arms.codex_auth() == "chatgpt"
if chatgpt:
if ctx.args.offline:
return out
if "codex_auth_checks" in ctx.versions:
return out + ctx.versions["codex_auth_checks"]
else:
try:
import urllib.request
with urllib.request.urlopen(cxn.gateway().rstrip("/") + "/models", timeout=10) as resp:
listed = [m.get("id") for m in json.load(resp).get("data", [])]
out.append(
(
"gateway lists the model",
"pass" if cxn.MODEL in listed else "fail",
f"{cxn.gateway()} {cxn.MODEL}",
)
)
except Exception as error: # noqa: BLE001
out.append(
("gateway reachable", "fail", f"{cxn.gateway()}: {type(error).__name__}: {error}")
)
if not with_models:
return out
mcp_path, _server = ctx.mcp[arm]
home = ctx.run_dir / f"preflight-{arm}-home"
shutil.rmtree(home, ignore_errors=True)
checks: list[tuple[str, str, str]] = []
try:
env = cxn.render_home(
home, mcp_path, cxn.MODEL, cxn.EFFORT, ca.system_prompt_for(SOURCE_ARM[arm]), arm
)
if chatgpt:
checks.extend(cxn.chatgpt_checks(cxn.CODEX_CLI, env, cxn.MODEL))
finally:
if chatgpt:
try:
arms.unlink_chatgpt_auth(home / ".codex")
except RuntimeError as error:
checks.append(("codex shared auth symlink", "fail", str(error)))
if chatgpt:
ctx.versions["codex_auth_checks"] = checks
return out + checks
cwd = ca.prepare_cwd(arm)
stream = ctx.run_dir / f"preflight-init-{arm}.tsv"
result = cxn.run_codex(
cxn.argv(),
env,
cwd,
"Reply OK. Do not call any tool.",
180,
3,
ctx.run_dir / f"preflight-{arm}-raw.tsv",
stream,
ctx.run_dir / f"preflight-{arm}.stderr",
server=cxn.SERVER_OF[arm],
)
summary = claude_events.summarize(claude_events.read_events(stream))
text = (summary.get("final_text") or "").strip()
# the shared system prompt asks for DONE at the end, so either answer is a working turn
ok = (
result.get("result_seen")
and text.upper().startswith(("OK", "DONE"))
and not summary["tool_calls"]["total"]
)
out.append(
(
f"init check {arm} (codex app-server, {cxn.MODEL})",
"pass" if ok else "fail",
f"reply={text[:40]!r} tools={summary['tool_calls']['total']} usage={result.get('codex_usage')}",
)
)
return out
def init_check(ctx: Ctx, arm: str) -> tuple[str, str]:
"""One trivial haiku call per arm through the real argv: verify the init event."""
if arm in ca.CUA_ARMS:
ensure_agent_daemon(ctx, arm)
mcp_path, server = ctx.mcp[arm]
cwd = ca.prepare_cwd(arm)
debug = ctx.run_dir / f"preflight-debug-{arm}.txt"
argv = ca.claude_argv(
mcp_config=mcp_path,
server=server,
model="claude-haiku-4-5",
max_turns=1,
max_budget_usd=1,
tool_search=ctx.args.tool_search == "default",
effort=None,
debug_file=debug,
system_prompt=ca.system_prompt_for(arm),
)
stream = ctx.run_dir / f"preflight-init-{arm}.tsv"
result = claude_driver.run_claude(
argv,
ca.claude_env(),
cwd,
"Reply OK. Do not call any tool.",
set(),
120,
stream,
ctx.run_dir / f"preflight-{arm}.stderr",
ctx.run_dir / f"preflight-{arm}-elicit.jsonl",
)
summary = claude_events.summarize(claude_events.read_events(stream))
ctx.ledger.append(
ctx.args.ledger_who,
f"preflight init check {arm}",
"claude-haiku-4-5",
summary.get("total_cost_usd"),
)
ctx.quota = merge_quota(ctx.quota, summary.get("quota_last"))
note_quota(ctx, summary.get("quota_last"), f"init check {arm}")
init = summary["init"]
problems = []
want_tools = sorted(ca.builtin_tools(ctx.args.tool_search == "default"))
if init["tools_builtin"] != want_tools:
problems.append(f"built-in tools {init['tools_builtin']} != {want_tools}")
connected = [s for s in init["mcp_servers"] if s.get("status") == "connected"]
if len(connected) != 1 or connected[0].get("name") != server or len(init["mcp_servers"]) != 1:
problems.append(f"mcp_servers {init['mcp_servers']}")
has_skill = "cua-driver" in init["skills"]
if has_skill != (arm in ca.CUA_ARMS):
problems.append(f"cua-driver skill present={has_skill}")
leaked = [s for s in init["skills"] if s != "cua-driver" and s not in BUNDLED_SKILLS_OK]
if leaked:
problems.append(f"unexpected skills {leaked}")
if init["plugins"] and any(not str(p).startswith("cc-plugin-") for p in init["plugins"]):
problems.append(f"non-builtin plugins {init['plugins']}")
deferred = ""
if debug.exists():
for line in debug.read_text("utf-8", "replace").splitlines():
if "Dynamic tool loading" in line:
deferred = line.split("] ", 1)[-1]
detail = (
f"tools={init['tools_builtin']} mcp_tools={init['mcp_tool_count']} skills={len(init['skills'])} "
f"baseline_prompt_tokens={summary['baseline_prompt_tokens']} cost=${summary.get('total_cost_usd')} {deferred}"
)
ctx.versions.setdefault("init_checks", {})[arm] = {
"tools_builtin": init["tools_builtin"],
"mcp_tool_count": init["mcp_tool_count"],
"skills": init["skills"],
"baseline_prompt_tokens_haiku": summary["baseline_prompt_tokens"],
"deferral_log": deferred,
"mcp_servers": init["mcp_servers"],
}
if problems:
return "fail", "; ".join(problems) + " | " + detail
return "pass", detail
BUNDLED_SKILLS_OK = {
"deep-research",
"design",
"design-sync",
"dataviz",
"update-config",
"verify",
"debug",
"code-review",
"simplify",
"batch",
"fewer-permission-prompts",
"doctor",
"loop",
"schedule",
"claude-api",
"workflow-authoring",
"run",
"run-skill-generator",
"plugin-authoring",
}
def v2_static_checks(ctx: Ctx) -> list[tuple[str, str, str]]:
"""Amendment 14: every task has one known category and is GUI-only, and no arm's argv offers a
shell or file tool (the same surface for every setup)."""
out: list[tuple[str, str, str]] = []
problems = v2.validate_tasks(
{t: task_spec(ctx.tasks[t]) for t in ctx.tasks}, ctx.task_ids, ctx.arm_names
)
cats = {t: task_spec(ctx.tasks[t]).get("category") for t in ctx.task_ids}
out.append(
(
"v2 tasks and categories",
"fail" if problems else "pass",
"; ".join(problems) or json.dumps(cats),
)
)
for arm in ctx.arm_names:
if arm in pia.ARMS:
tools = [pia.claude_name(t) for t in pia.TOOLS if not t.startswith("mcp__")]
bad = [t for t in tools if t in v2.FORBIDDEN_BUILTINS or t == "Task"]
out.append(
(
f"v2 GUI-only surface {arm}",
"fail" if bad else "pass",
f"pi tools {list(pia.TOOLS)}" + (f"; forbidden {bad}" if bad else ""),
)
)
continue
argv = ca.claude_argv(
mcp_config=Path("/dev/null"),
server=(ctx.mcp.get(arm) or (None, "server"))[1],
model=ctx.args.model,
max_turns=45,
max_budget_usd=ctx.args.max_budget_usd,
tool_search=ctx.args.tool_search == "default",
coding_tools=False,
)
tools = argv[argv.index("--tools") + 1].split(",")
allowed = (
argv[argv.index("--allowedTools") + 1].split(",") if "--allowedTools" in argv else []
)
bad = [t for t in tools + allowed if t in v2.FORBIDDEN_BUILTINS]
out.append(
(
f"v2 GUI-only surface {arm}",
"fail" if bad else "pass",
f"tools {tools}, allowed {allowed}" + (f"; forbidden {bad}" if bad else ""),
)
)
return out
def preflight(ctx: Ctx, with_models: bool = True) -> list[tuple[str, str, str]]:
args = ctx.args
if bu.ARM in ctx.arm_names:
return bu.preflight()
checks: list[tuple[str, str, str]] = []
def add(name: str, status: str, detail: str) -> None:
checks.append((name, status, detail))
print(f"[{status.upper():4}] {name}: {detail}", flush=True)
pins = ca.load_pins()
if getattr(args, "bench_v2", False):
for name, status, detail in v2_static_checks(ctx):
add(name, status, detail)
if any(a not in pia.ARMS for a in ctx.arm_names):
add(
"claude binary",
"pass" if ca.CLAUDE_BIN.is_file() else "fail",
f"{ca.CLAUDE_BIN} {ctx.versions.get('claude')}",
)
if any(a in pia.ARMS for a in ctx.arm_names):
pi = ctx.versions.get("pi") or {}
add("pi binary", "pass" if pi.get("pi_version") else "fail", f"{pia.PI_BIN} {pi}")
add(
"terminal.app ancestor",
"skip"
if desktop.detect_platform() == "linux"
else "pass"
if terminal_ancestor()
else ("warn" if args.allow_non_terminal else "fail"),
"runner started from Terminal.app"
if terminal_ancestor()
else "not started from Terminal.app (required for arm cc-codex-cu)",
)
free = rec.free_gb(ctx.run_dir)
add(
"disk",
"pass" if free > ctx.args.disk_floor_gb else "fail",
f"{free:.1f} GB free (floor {ctx.args.disk_floor_gb:g})",
)
git_root = subprocess.run(
["git", "-C", str(ca.CWD_ROOT.parent), "rev-parse", "--show-toplevel"],
capture_output=True,
text=True,
)
add(
"agent cwd outside any git checkout",
"pass" if git_root.returncode != 0 else "fail",
str(ca.CWD_ROOT),
)
for name, status, detail in check_pins(pins, ctx.arm_names):
add(name, status, detail)
offline = bool(getattr(args, "offline", False))
driver_arms = [pia.SOURCE_ARM.get(a, a) for a in ctx.arm_names]
if any(ca.CUA_BUILDS[a].label == "main" for a in driver_arms if a in ca.CUA_BUILDS):
main = pins.get("cua_main", {})
spec = ca.CUA_BUILDS["cc-cua-driver-main"]
got_bin = ca.sha256_file(spec.bin) if spec.bin.is_file() else None
for other in [
a
for a in dict.fromkeys(driver_arms)
if a in ca.CUA_BUILDS and ca.CUA_BUILDS[a].label == "main"
]:
ob = ca.CUA_BUILDS[other].bin
got = ca.sha256_file(ob) if ob.is_file() else None
key = ca.CUA_BUILDS[other].binary_pin
add(
f"{other} binary matches cua_main.{key}",
"pass" if got and got == main.get(key) else "fail",
str(got),
)
got_skills = ca.sha256_tree(spec.skills) if spec.skills.is_dir() else None
add(
"pin cua_main.binary_sha256",
"pass" if got_bin and got_bin == main.get("binary_sha256") else "fail",
str(got_bin),
)
add(
"pin cua_main.skills_tree_sha256",
"pass" if got_skills and got_skills == main.get("skills_tree_sha256") else "fail",
str(got_skills),
)
for cua_arm in [a for a in ca.CUA_ARMS if a in driver_arms]:
spec = ca.CUA_BUILDS[cua_arm]
try:
ensure_agent_daemon(ctx, cua_arm)
for name, status, detail in check_daemon(pins, cua_arm):
add(name, status, detail)
if desktop.detect_platform() == "linux":
for check in desktop.doctor(spec.bin, spec.socket, spec.home):
add(check.name, check.status, check.detail)
health = ca.cua_health(spec.socket, spec.home, spec.bin)
ctx.versions.setdefault("builds", {}).setdefault(cua_arm, {})["cua_daemon_version"] = (
health.get("build", {}).get("version")
)
if cua_arm == "cc-cua-driver":
ctx.versions["cua_daemon_version"] = health.get("build", {}).get("version")
except Exception as error: # noqa: BLE001
add(f"{cua_arm} daemon/MCP", "fail", f"{type(error).__name__}: {error}")
for native_arm in [a for a in cxn.MCP_ARMS if a in ctx.arm_names]:
if not cxn.CODEX_CLI.is_file():
add("Codex CLI in the ChatGPT app", "fail", str(cxn.CODEX_CLI))
continue
for name, status, detail in native_codex_checks(
ctx, native_arm, with_models and not offline
):
add(name, status, detail)
helper_sources = {
SOURCE_ARM.get(a, a) for a in ctx.arm_names
} # A23: also for cx-claude-cu-helper
for helper_arm in [a for a in ca.CU_HELPER_ARMS if a in helper_sources]:
observed = ca.cu_helper_observed(ca.CU_HELPER_BUILDS[helper_arm])
ctx.versions.setdefault("claude_cu_helper", {}).update(observed)
for name, status, detail in ca.check_cu_helper_pins(pins, observed):
add(name, status, detail)
for name, status, detail in cu_helper_live_checks(ctx, helper_arm):
add(name, status, detail)
cdb_ids = [t for t in ctx.task_ids if task_spec(ctx.tasks[t]).get("kind") == "cdb"]
if cdb_ids:
want = dict(ca.load_pins().get("cdb_pack", {}).get("tree_sha256", {}))
want_heldout = cdb_adapter.heldout_pins()
kits_checked: set[str] = set()
for tid in cdb_ids:
spec = task_spec(ctx.tasks[tid])
pins_for = want_heldout if spec.get("split") == "heldout" else want
try:
probe = cdb_adapter.CdbTask(spec, ctx.run_dir)
got = probe._digest_hidden() or cdb_adapter.tree_sha256(probe.bundle)
ok = got == pins_for.get(spec["pack_task"])
add(f"CDB pack {tid} matches its pinned digest", "pass" if ok else "fail", got[:16])
kit = cdb_adapter.shared_kit(spec)
if kit is not None and str(kit) not in kits_checked:
kits_checked.add(str(kit))
kit_key = str(Path(spec["pack_task"]).parent / "_kit")
got_kit = cdb_adapter.tree_sha256(kit)
add(
f"CDB shared kit {kit_key} matches its pinned digest",
"pass" if got_kit == want.get(kit_key) else "fail",
got_kit[:16],
)
names = cdb_adapter.allowed_app_names(spec)
add(f"CDB {tid} descriptor readable", "pass", f"{len(names)} app names")
except Exception as error: # noqa: BLE001
add(f"CDB pack {tid}", "fail", f"{type(error).__name__}: {error}")
if desktop.detect_platform() == "macos":
for app in ("Google Chrome", "LibreOffice", "Gnucash"):
add(
f"CDB app installed: {app}",
"pass" if Path(f"/Applications/{app}.app").is_dir() else "fail",
f"/Applications/{app}.app",
)
else:
for tid in cdb_ids:
probe = cdb_adapter.CdbTask(task_spec(ctx.tasks[tid]), ctx.run_dir)
for prerequisite in probe.descriptor.get("prerequisites", []):
try:
done = subprocess.run(
[probe.sub(p) for p in prerequisite["check"]],
cwd=probe.sub(prerequisite.get("cwd", str(probe.bundle))),
env=desktop.desktop_env(Path.home()),
capture_output=True,
timeout=30,
)
add(
f"CDB {tid} prerequisite {prerequisite['id']}",
"pass" if done.returncode == 0 else "fail",
str(prerequisite["check"]),
)
except (OSError, subprocess.TimeoutExpired) as error:
add(f"CDB {tid} prerequisite {prerequisite['id']}", "fail", str(error))
electron, missing = cdb_adapter.missing_electron_apps()
add(
"CDB Electron apps installed (npm ci + install.js)",
"fail" if missing else "pass",
f"{len(electron) - len(missing)} of {len(electron)}"
+ (f"; missing: {', '.join(missing)}" if missing else ""),
)
add(
"CDB evaluator isolation (pack unreadable by the agent's user)",
"pass" if os.environ.get("CDB_EVAL_SUDO") == "1" else "warn",
"CDB_EVAL_SUDO=1: evaluator, oracle and hidden tests run as user cdbeval",
)
add(
"CDB disposable-environment flag",
"pass" if os.environ.get("CDB_BENCH_DISPOSABLE") == "1" else "fail",
"CDB_BENCH_DISPOSABLE=1 (the runner kills Electron/Chrome/LibreOffice by name)",
)
build = Path(args.build_dir) if args.build_dir else None
try:
for name in BENCH_APPS:
desktop.bench_app_argv(name, build)
ok_build = True
except (OSError, ValueError, StopIteration):
ok_build = False
add("BenchLab + BenchSentinel builds", "pass" if ok_build else "fail", str(build))
copies = registered_bench_copies()
per_name = {n: [c for c in copies if Path(c).name == n] for n in BENCH_APPS}
ok_copies = desktop.detect_platform() == "linux" or all(len(v) == 1 for v in per_name.values())
add(
"exactly one registered copy of BenchLab and BenchSentinel",
"skip" if desktop.detect_platform() == "linux" else "pass" if ok_copies else "fail",
"not applicable on Linux" if desktop.detect_platform() == "linux" else json.dumps(per_name),
)
try:
if desktop.detect_platform() == "macos":
subprocess.run(["/usr/bin/open", "-a", "Calculator"], check=True, timeout=30)
with capture_subject(ctx.run_dir / "preflight-capture" / "subject"):
for arm in ctx.arm_names:
add(*real_capture_check(ctx, arm))
except (OSError, subprocess.SubprocessError) as error:
for arm in ctx.arm_names:
add(f"{arm} real capture", "fail", str(error)[:300])
finally:
reset_needs_apps(["Calculator"])
ps = subprocess.run(["ps", "-axo", "pid=,command="], capture_output=True, text=True).stdout
leftovers = [
ln.split(None, 1)[1][:80]
for ln in ps.splitlines()
if any(
n in ln
for n in (
"BenchLab.app/Contents/MacOS",
"BenchSentinel.app/Contents/MacOS",
"/Calculator.app/Contents/MacOS/Calculator",
str(HERE / "linux" / "benchlab.py"),
str(HERE / "linux" / "sentinel.py"),
)
)
]
add(
"no leftover BenchLab/Sentinel/Calculator",
"pass" if not leftovers else "warn",
f"{leftovers}",
)
if ctx.recorder is not None and ctx.recorder.name != "none":
test = ctx.run_dir / "preflight-rec"
shutil.rmtree(test, ignore_errors=True)
started = ctx.recorder.start(test)
time.sleep(3.0)
raw = ctx.recorder.stop() if started else None
dur = rec.ffprobe_duration(raw) if raw else None
try:
if not raw or not dur or dur <= 0.5:
raise RuntimeError(
f"{raw} duration={dur} err={getattr(ctx.recorder, 'last_error', None)}"
)
add("recorder real capture (3 s test)", "pass", rec.capture_detail(raw))
except (OSError, RuntimeError, subprocess.SubprocessError) as error:
add("recorder real capture (3 s test)", "fail", str(error)[:300])
else:
add("screen recording", "warn", "disabled (--no-recorder)")
gate = core.gate_decision(
core.latest_known_quota(QUOTA_LATEST, ctx.ledger.path), ctx.args.seven_day_stop
)
add(
"quota gate from the latest known reading",
"warn"
if gate["action"] == "gated"
and all(a in NO_CLAUDE_SEAT for a in ctx.arm_names) # no Claude seat in use
else "fail"
if gate["action"] == "gated"
else ("warn" if gate["action"] == "unknown" else "pass"),
gate["reason"],
)
if (WORK / "HOLD").exists():
add("HOLD file", "fail", (WORK / "HOLD").read_text("utf-8").strip()[:200])
for arm in [a for a in ctx.arm_names if a in pia.ARMS] if with_models and not offline else []:
try:
source = pia.SOURCE_ARM[arm]
ensure_agent_daemon(ctx, source)
status, detail = pia.init_check(
arm,
ctx.mcp[arm][0],
ca.prepare_cwd(source),
ca.system_prompt_for(source),
ctx.run_dir / f"preflight-{arm}",
)
add(f"init event check {arm}", status, detail)
except Exception as error: # noqa: BLE001
add(f"init event check {arm}", "fail", f"{type(error).__name__}: {error}")
claude_arms = [a for a in ctx.arm_names if a not in NO_CLAUDE_SEAT]
if with_models and not offline and claude_arms: # a native-Codex-only run uses no Claude seat
try:
ok, detail = quota_probe(ctx)
add("quota probe (haiku-4-5)", "pass" if ok else "fail", detail)
except Exception as error: # noqa: BLE001
add("quota probe", "fail", f"{type(error).__name__}: {error}")
for arm in claude_arms:
try:
status, detail = init_check(ctx, arm)
add(f"init event check {arm}", status, detail)
except Exception as error: # noqa: BLE001
add(f"init event check {arm}", "fail", f"{type(error).__name__}: {error}")
return checks
# ---------------------------------------------------------------- setup
def positive_gb(text: str) -> float:
value = float(text)
if not math.isfinite(value) or value <= 0:
raise argparse.ArgumentTypeError(f"must be a finite number > 0: {text}")
return value
def build_parser() -> argparse.ArgumentParser:
p = argparse.ArgumentParser(
description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
)
p.add_argument(
"command", choices=["preflight", "dry-run", "run", "status", "finalize", "gate-check"]
)
p.add_argument("--run-id", default=None, help="name under runs/ (default: UTC timestamp)")
p.add_argument("--runs-dir", type=Path, default=DEFAULT_RUNS)
p.add_argument("--ledger", type=Path, default=DEFAULT_LEDGER)
p.add_argument("--ledger-who", default="runner")
p.add_argument(
"--arms", nargs="+", default=list(arms.DEFAULT_CLAUDE_ARMS), choices=list(arms.ALL_ARMS)
)
p.add_argument("--only-arm", default=None)
p.add_argument(
"--tasks",
nargs="+",
default=None,
help="explicit task ids, in this order (default: priority order of all MB tasks)",
)
p.add_argument("--only-task", default=None)
p.add_argument(
"--task-set",
default="v2",
help="with --bench-v2: v2 (the ten registered tasks, default), or v2-public / v2-heldout for one split "
"(see taskpack/v2-taskset.json)",
)
p.add_argument(
"--phase1-runs",
type=int,
default=3,
help="runs per task in phase 1 (task blocks of interleaved pairs)",
)
p.add_argument(
"--phase2-runs",
type=int,
default=2,
help="extra runs per task in phase 2, only after phase 1 is complete for all tasks and quota allows",
)
p.add_argument(
"--cutoff-utc", default=None, help="ISO time; no trial starts after it (STOPPED_TIME)"
)
p.add_argument("--schedule-seed", type=int, default=20261005)
p.add_argument("--model", default="claude-sonnet-5-5")
p.add_argument(
"--effort", default=None, choices=[None, "low", "medium", "high", "xhigh", "max"]
)
p.add_argument("--max-turns", type=int, default=None, help="override every task's max_turns")
p.add_argument(
"--timeout-s", type=int, default=None, help="override every task's wall-time limit"
)
p.add_argument(
"--max-budget-usd", type=float, default=6.0, help="per-trial runaway guard passed to claude"
)
p.add_argument(
"--budget-cap-usd",
type=float,
default=None,
help="optional total cap on the ledger (default: none, subscription)",
)
p.add_argument("--seven-day-stop", type=float, default=core.SEVEN_DAY_STOP)
p.add_argument(
"--tool-search",
choices=["default", "off"],
default="default",
help="default: ToolSearch is in the built-in tool set so Claude Code's own deferral applies per arm",
)
p.add_argument("--tell-budget", action=argparse.BooleanOptionalAction, default=True)
p.add_argument("--cua-bin", type=Path, help="driver executable (required on Linux)")
p.add_argument("--cua-skills", type=Path, help="matching driver skill directory")
p.add_argument("--pins", type=Path, help="platform-specific identity pins")
p.add_argument(
"--build-dir",
type=Path,
default=None,
help="dir with BenchLab.app and BenchSentinel.app (swift/build.sh)",
)
p.add_argument("--no-sentinel", action="store_true")
p.add_argument(
"--check-occlusion",
action=argparse.BooleanOptionalAction,
default=True,
help="before a BenchLab probe, move other windows off BenchLab and record it (Amendment 4, A4.8)",
)
p.add_argument(
"--park-pointer",
action=argparse.BooleanOptionalAction,
default=True,
help="park the real pointer at a fixed point outside every registered window, verify it and record "
"it in the trial row, before each trial; a failed park fails the trial setup (Amendment 24)",
)
p.add_argument("--no-recorder", action="store_true")
p.add_argument(
"--disk-floor-gb",
type=positive_gb,
default=DISK_FLOOR_GB,
help="free-space floor for preflight and every trial admission",
)
p.add_argument(
"--codex-cu-mcp",
type=Path,
default=None,
help="MCP config for arm cc-codex-cu (default WORK/codex-access/mcp.json)",
)
p.add_argument(
"--idle-min",
type=float,
default=0.0,
help="warn (and record) when HID idle is below this; never blocks",
)
p.add_argument(
"--smoke", action="store_true", help="mark rows smoke:true (excluded from analysis)"
)
p.add_argument(
"--claude-bin",
type=Path,
default=None,
help="testing only: a stand-in for the claude binary",
)
p.add_argument("--allow-non-terminal", action="store_true")
p.add_argument("--allow-codex-arms", action="store_true")
p.add_argument(
"--no-model-preflight",
action="store_true",
help="skip the three small Haiku calls (quota probe, init checks)",
)
p.add_argument(
"--offline",
action="store_true",
help="preflight only: skip model calls; still start daemons, GUI captures and recording",
)
p.add_argument(
"--allow-unknown-quota",
action="store_true",
help="start even when no quota reading exists (default: refuse)",
)
p.add_argument("--ignore-hold", action="store_true", help="start although WORK/HOLD exists")
p.add_argument(
"--bench-v2",
action="store_true",
help="Bench v2 (Amendment 14): GUI-only v2 task list, categories, background score, interruption probes",
)
p.add_argument(
"--condition",
choices=list(v2.CONDITIONS),
default="foreground",
help="v2 (Amendment 15): foreground, or background (a user window keeps focus; the target app is behind it)",
)
p.add_argument(
"--gui-only-enforce",
action=argparse.BooleanOptionalAction,
default=True,
help="v2: end a trial at its first GUI-only violation (default); --no-gui-only-enforce only records it",
)
return p
def make_ctx(args: argparse.Namespace) -> Ctx:
arm_names = [args.only_arm] if args.only_arm else list(args.arms)
if bu.ARM in arm_names:
bu.require_chatgpt()
run_id = args.run_id or datetime.now(timezone.utc).strftime("run-%Y%m%dT%H%M%SZ")
run_dir = (args.runs_dir / run_id).resolve()
if args.command == "dry-run":
run_dir = Path(tempfile.mkdtemp(prefix="cdb-dry-"))
run_dir.mkdir(parents=True, exist_ok=True)
(run_dir / "trials").mkdir(exist_ok=True)
tasks = load_tasks(HERE / "probes")
bench_v2 = bool(getattr(args, "bench_v2", False))
task_set = getattr(args, "task_set", "v2") or "v2"
sets = v2.task_sets()
if task_set not in sets:
raise SystemExit(f"unknown --task-set {task_set!r}; known {sorted(sets)}")
defaults = list(sets[task_set]) if bench_v2 else [t for t in tasks if default_task(tasks, t)]
if bench_v2 and task_set != "v2":
# a set other than v2 honours each task's `conditions` (taskpack/v2-taskset.json)
manifest = {e["id"]: e for e in v2.load_taskset()["tasks"]}
condition = getattr(args, "condition", "foreground")
specs = {
t: {**(task_spec(tasks[t]) if t in tasks else {}), **manifest.get(t, {})}
for t in defaults
}
for t in defaults: # a held-out entry carries no conditions; its selector does
if t in tasks and "conditions" in task_spec(tasks[t]):
specs[t]["conditions"] = task_spec(tasks[t])["conditions"]
defaults = v2.tasks_for_condition(defaults, condition, specs)
selected = args.tasks or ([args.only_task] if args.only_task else defaults)
if args.only_task and args.tasks is None:
selected = [args.only_task]
unknown = [t for t in selected if t not in tasks]
if unknown:
raise SystemExit(f"unknown tasks {unknown}; known {sorted(tasks)}")
if bench_v2 or bu.ARM in arm_names:
problems = v2.validate_tasks({t: task_spec(tasks[t]) for t in tasks}, selected, arm_names)
if problems:
raise SystemExit("bench v2: " + "; ".join(problems))
explicit = bool(args.tasks) or bench_v2 # v2 keeps the registered order (A14.6)
task_ids = core.order_tasks(selected, explicit=explicit)
full_ids = task_ids if args.tasks else core.order_tasks(defaults, explicit=bench_v2)
unsupported = []
if desktop.detect_platform() == "linux":
unsupported = [
f"unsupported-platform: {a} requires macOS"
for a in arm_names
if a not in ca.CUA_ARMS + pia.ARMS
]
for reason in unsupported:
print(reason, file=sys.stderr)
arm_names = [a for a in arm_names if a in ca.CUA_ARMS + pia.ARMS]
if not arm_names:
raise SystemExit("no supported arms remain: " + "; ".join(unsupported))
if args.pins:
ca.PINS_FILE = args.pins.resolve()
if args.cua_bin:
if not args.cua_skills:
raise SystemExit("--cua-bin requires --cua-skills from the same build")
ca.CUA_BIN = args.cua_bin.resolve()
ca.CUA_SKILLS = args.cua_skills.resolve()
for name, build in ca.CUA_BUILDS.items():
ca.CUA_BUILDS[name] = replace(build, executable=ca.CUA_BIN, skills=ca.CUA_SKILLS)
if ca.SCRIPT_FLAG not in build.daemon_env and ca.NO_SCRIPT_FLAG not in build.daemon_env:
# the explicit build ships run_script; only the script arm may expose it
ca.CUA_BUILDS[name] = replace(
ca.CUA_BUILDS[name], daemon_env=(*build.daemon_env, ca.NO_SCRIPT_FLAG)
)
codex = [a for a in arm_names if a in arms.CODEX_FALLBACK_ARMS]
if codex and not args.allow_codex_arms:
raise SystemExit(f"arms {codex} are fallback arms; pass --allow-codex-arms")
if len(arm_names) < 2 and args.command == "run":
# the rotation (task_pos + run_index) mod n works for any n >= 2 (four arms: Amendment 4)
print(
f"note: running {len(arm_names)} arm; there is no arm order to rotate", file=sys.stderr
)
if args.claude_bin is not None:
ca.CLAUDE_BIN = args.claude_bin
ctx = Ctx(
args, run_dir, core.Ledger(args.ledger), tasks, task_ids, arm_names, full_task_ids=full_ids
)
ctx.cutoff = core.parse_utc(args.cutoff_utc) if args.cutoff_utc else None
os_version = sw_vers()
ctx.versions = {
"claude": claude_version(),
"platform": desktop.detect_platform(),
"unsupported_arms": unsupported,
"os_version": os_version,
"macos": os_version if desktop.detect_platform() == "macos" else None,
"bench_repo_commit": git_commit(HERE),
"bench_src_sha256": src_hash(),
}
return ctx
def setup_arms(ctx: Ctx) -> None:
if desktop.detect_platform() == "linux" and not (
ctx.args.cua_bin and ctx.args.cua_skills and ctx.args.pins
):
raise SystemExit(
"Linux requires explicit --cua-bin, --cua-skills and --pins; macOS build identities cannot be reused"
)
pins = ca.load_pins()
if desktop.detect_platform() == "linux":
required = ("cua_driver_version", "cua_driver_binary_sha256", "cua_skills_tree_sha256")
if pins.get("platform") != "linux" or not all(pins.get(k) for k in required):
raise SystemExit(
"Linux pins require platform=linux and driver version, binary and skills hashes"
)
observed = ca.observed_pins(
include_codex=any(a in ca.CODEX_ARMS or a in cxn.ARMS for a in ctx.arm_names),
include_cua="cc-cua-driver" in {SOURCE_ARM.get(a, a) for a in ctx.arm_names},
)
ctx.versions.update(
pins_expected=pins,
pins_observed=observed,
macos_build=observed.get("macos_build"),
chatgpt_app_version=observed.get("chatgpt_app_version"),
unified_computer_use_plugin_version=observed.get("unified_computer_use_plugin_version"),
cua_repl_package_version=observed.get("cua_repl_package_version"),
codex_computer_use_service_version=observed.get("codex_computer_use_service_version"),
cua_driver_version=ca.cua_version_string(),
cua_driver_sha256=ca.sha256_file(ca.CUA_BIN) if ca.CUA_BIN.is_file() else None,
cua_skills_tree_sha256=ca.sha256_tree(ca.CUA_SKILLS) if ca.CUA_SKILLS.is_dir() else None,
builds={
arm: {
"label": build.label,
"cua_driver_version": ca.cua_version_string(build.bin),
"cua_driver_sha256": ca.sha256_file(build.bin) if build.bin.is_file() else None,
"cua_driver_git_sha": pins.get("cua_driver_git_sha")
if arm == "cc-cua-driver"
else pins.get("cua_main", {}).get("git_sha"),
"cua_skills_tree_sha256": ca.sha256_tree(build.skills)
if build.skills.is_dir()
else None,
}
for arm, build in ca.CUA_BUILDS.items()
if arm in ctx.arm_names
or arm == "cc-cua-driver"
or arm in {SOURCE_ARM.get(a) for a in ctx.arm_names}
},
pins=pins,
system_prompt_sha256=hashlib.sha256(ca.SYSTEM_PROMPT.encode()).hexdigest(),
)
for arm in ctx.arm_names:
if arm in arms.CLAUDE_ARMS:
try:
ctx.mcp[arm] = ca.mcp_config_for(arm, ctx.run_dir, ctx.args.codex_cu_mcp)
except (FileNotFoundError, ValueError) as error:
raise SystemExit(f"arm {arm} unavailable: {error}")
elif (
arm in cxn.MCP_ARMS
): # A20/A23: the source Claude arm's MCP entry, copied unmodified, driven by Codex CLI
try:
path, _server = ca.mcp_config_for(
SOURCE_ARM[arm], ctx.run_dir, ctx.args.codex_cu_mcp
)
cxn.server_entry(path, arm)
ctx.mcp[arm] = (path, cxn.SERVER_OF[arm])
except (FileNotFoundError, ValueError) as error:
raise SystemExit(f"arm {arm} unavailable: {error}")
ctx.versions["codex_native"] = cxn.observed()
elif (
arm in pia.ARMS
): # the source arm's MCP entry; pi_arms.render_agent_dir copies it per trial
ctx.mcp[arm] = ca.mcp_config_for(SOURCE_ARM[arm], ctx.run_dir)
ctx.versions["pi"] = pia.observed()
if ctx.args.build_dir or desktop.detect_platform() == "linux":
apps: dict[str, str] = {}
for name in BENCH_APPS:
argv = desktop.bench_app_argv(name, ctx.args.build_dir)
apps[name] = ca.sha256_file(Path(argv[-1]))
ctx.versions["bench_apps_exe_sha256"] = apps
for codex_arm in [a for a in ctx.mcp if a in ca.CODEX_ARMS]:
key = "codex_cu_mcp_sha256" if codex_arm == "cc-codex-cu" else f"{codex_arm}_mcp_sha256"
ctx.versions[key] = ca.sha256_file(ctx.mcp[codex_arm][0])
def start_recorder(ctx: Ctx) -> None:
if ctx.args.no_recorder:
ctx.recorder = rec.NullRecorder()
return
ctx.rec_daemon = ca.start_cua_daemon(ca.RECORDER_SOCKET, ca.RECORDER_STATE, overlay=False)
ctx.recorder = rec.CuaRecorder(
ca.CUA_BIN, ca.RECORDER_SOCKET, ca.cua_env(ca.RECORDER_STATE / "home")
)
ctx.compress = rec.CompressQueue()
# A recorded trial whose compression died with an earlier runner still has its raw video (CompressQueue
# deletes it only after video.json is on disk): compress it now.
for row in core.load_rows(ctx.results_path):
attempt = ctx.run_dir / "trials" / row["trial_id"] / f"a{row.get('attempt')}"
raw = attempt / "rec" / "recording.mp4"
if row.get("video") and raw.is_file() and not rec.compressed(attempt / "video"):
ctx.log(f"compressing the video of {row['trial_id']} a{row.get('attempt')} again")
ctx.compress.submit(raw, attempt / "video")
def shutdown(ctx: Ctx) -> None:
if ctx.compress:
ctx.log(f"waiting for {ctx.compress.pending()} compression job(s)")
ctx.compress.join()
ctx.compress.close()
if ctx.recorder:
ctx.recorder.close()
agent_socket = ca.CUA_BUILDS[ctx.daemon_arm].socket if ctx.daemon_arm else ca.AGENT_SOCKET
for proc, sock in ((ctx.rec_daemon, ca.RECORDER_SOCKET), (ctx.daemon, agent_socket)):
if proc is not None:
claude_driver.kill_group(proc.pid)
try:
proc.wait(timeout=5)
except subprocess.TimeoutExpired:
pass
try:
os.unlink(sock)
except OSError:
pass
def finalize(ctx: Ctx) -> dict[str, Any]:
rows = core.load_rows(ctx.results_path)
blocks = ctx.blocks()
status = core.block_status(rows, blocks)
rows = core.flag_incomplete(rows, blocks)
core.write_atomic(ctx.results_path, "".join(json.dumps(r) + "\n" for r in rows))
summary = {
"blocks": status,
"blocks_complete": sum(1 for v in status.values() if v["complete"]),
"blocks_total": len(status),
"trials": len([r for r in rows if r.get("final", True)]),
}
core.write_atomic(ctx.run_dir / "blocks.json", json.dumps(summary, indent=2) + "\n")
return summary
def write_manifest(ctx: Ctx, first_schedule: list[dict[str, Any]]) -> None:
args = ctx.args
manifest = {
"created_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"),
"run_id": ctx.run_dir.name,
"argv": sys.argv,
"arms": ctx.arm_names,
"tasks": ctx.task_ids,
"schedule_rule": (
"task-major blocks in priority order (MB-01.. then others); phase 1 = runs 1.."
f"{args.phase1_runs} per task, phase 2 = next {args.phase2_runs} runs per task only after phase 1 is complete "
"for all tasks and quota allows; each run is a pair of back-to-back trials, first arm = arms[0] if "
"(task_pos + run_index) even else arms[1], 0-based; both arms share the run's seed"
),
"schedule_seed_recorded": args.schedule_seed,
"phases": {"phase1_runs": args.phase1_runs, "phase2_runs": args.phase2_runs},
"cutoff_utc": args.cutoff_utc,
"model": args.model,
"effort": args.effort,
"max_budget_usd_per_trial": args.max_budget_usd,
"budget_cap_usd": args.budget_cap_usd,
"seven_day_stop": args.seven_day_stop,
"tool_search": args.tool_search,
"system_prompt": ca.SYSTEM_PROMPT,
"system_prompt_sha256_by_arm": {
a: hashlib.sha256(ca.system_prompt_for(SOURCE_ARM.get(a, a)).encode()).hexdigest()
for a in ctx.arm_names
},
"system_prompt_sha256_by_arm_browser": {
a: hashlib.sha256(
ca.system_prompt_for(SOURCE_ARM.get(a, a), browser=True).encode()
).hexdigest()
for a in ctx.arm_names
},
"builtin_tools": ca.builtin_tools(args.tool_search == "default"),
"claude_env_allowlist": list(ca.CLAUDE_ENV_ALLOW),
"claude_env_fixed": ca.CLAUDE_ENV_FIXED,
"versions": ctx.versions,
"recorder": getattr(ctx.recorder, "name", "none"),
"first_block_schedule": first_schedule,
"arm_descriptions": {
a: ca.ARM_DESCRIPTIONS.get(a) or pia.DESCRIPTIONS.get(a, a) for a in ctx.arm_names
},
"bench_version": v2.BENCH_VERSION if getattr(args, "bench_v2", False) else 1,
"bench_v2": {
"categories": v2.CATEGORIES,
"task_set": getattr(args, "task_set", "v2"),
"task_splits": {
t: task_spec(ctx.tasks[t]).get("split", "public") for t in ctx.task_ids
},
"task_categories": {t: task_spec(ctx.tasks[t]).get("category") for t in ctx.task_ids},
"gui_only_enforce": getattr(args, "gui_only_enforce", True),
"condition": getattr(args, "condition", "foreground"),
"user_window_frame": v2.USER_WINDOW_FRAME,
"background_brief": v2.BACKGROUND_BRIEF,
"exec_patterns": list(v2.EXEC_PATTERNS),
"side_door_bundles": v2.SIDE_DOOR_BUNDLES,
"side_door_processes": list(v2.SIDE_DOOR_PROCESSES),
"front_grace_samples": v2.FRONT_GRACE_SAMPLES,
}
if getattr(args, "bench_v2", False)
else None,
"price_fallback_usd_per_mtok_ASSUMED": PRICE_FALLBACK,
"example_argv_task": ctx.task_ids[0],
"example_argv": {
a: pia.argv(
ca.system_prompt_for(SOURCE_ARM[a]), Path(ca.CWD_ROOT) / ".claude/skills/cua-driver"
)
if a in pia.ARMS
else ca.claude_argv(
mcp_config=ctx.mcp[a][0],
server=ctx.mcp[a][1],
model=args.model,
max_turns=args.max_turns or 30,
max_budget_usd=args.max_budget_usd,
tool_search=args.tool_search == "default",
effort=args.effort,
system_prompt=ca.system_prompt_for(
SOURCE_ARM.get(a, a),
browser=bool(task_spec(ctx.tasks[ctx.task_ids[0]]).get("browser")),
),
)
for a in ctx.arm_names
if a in ctx.mcp
},
}
path = ctx.run_dir / "manifest.json"
if path.exists() and core.load_rows(ctx.results_path): # a resume keeps the first start time
old = json.loads(path.read_text("utf-8"))
manifest["resumed_utc"] = [*old.get("resumed_utc", []), manifest["created_utc"]]
manifest["created_utc"] = old.get("created_utc")
core.write_atomic(path, json.dumps(manifest, indent=2) + "\n")
def run_loop(ctx: Ctx) -> str:
args = ctx.args
rows = core.load_rows(ctx.results_path)
done = core.completed_trial_ids(rows, smoke=bool(args.smoke))
blocks = ctx.blocks()
ctx.set_state(blocks_total=len(blocks))
if not ctx.block_durations:
# A resumed run has no block timings yet: seed them from the counted trials of finished blocks
# (sum of trial wall times, so a stop inside a block does not inflate it), so block_fits can decide.
per_block: dict[str, float] = {}
for row in core.load_rows(ctx.results_path):
if row.get("final") and not row.get("smoke") and row.get("wall_s"):
per_block[row["block"]] = per_block.get(row["block"], 0.0) + float(row["wall_s"])
finished = {b["id"] for b in blocks if all(e["trial_id"] in done for e in b["entries"])}
ctx.block_durations.extend(v for k, v in per_block.items() if k in finished)
reason = "DONE"
complete = 0
try:
for block in blocks:
if block["phase"] == 2:
# Phase 2 only when phase 1 is complete for every task, quota allows and the block fits.
final_ids = done | {
e["trial_id"] for b in blocks for e in b["entries"] if e["trial_id"] in done
}
gate = core.quota_gate(ctx.quota, args.seven_day_stop)
if not core.phase2_allowed(blocks, final_ids, gate["action"] == "go"):
raise StopRun(
"QUOTA" if gate["action"] != "go" else "INCOMPLETE_PHASE1", gate["reason"]
)
est = None
if ctx.block_durations:
est = sorted(ctx.block_durations)[len(ctx.block_durations) // 2] * (
len(block["entries"]) / 6.0
)
if not core.block_fits(ctx.cutoff, est):
raise StopRun(
"TIME",
f"phase-2 block {block['id']} does not fit before the cutoff (estimate {est})",
)
todo = [e for e in block["entries"] if e["trial_id"] not in done]
if not todo:
complete += 1
continue
started = time.monotonic()
ctx.set_state(phase=block["phase"], block=block["id"])
ctx.log(f"block {block['id']} start ({len(todo)} of {len(block['entries'])} trials)")
for entry in todo:
row = execute_trial(ctx, entry)
if row.get("final"):
done.add(entry["trial_id"])
complete += 1
ctx.block_durations.append(time.monotonic() - started)
ctx.set_state(blocks_complete=complete)
ctx.log(f"block {block['id']} complete in {ctx.block_durations[-1]:.0f}s")
except StopRun as stop:
reason = stop.reason
ctx.log(f"STOPPED_{stop.reason}: {stop.detail}")
(ctx.run_dir / f"STOPPED_{stop.reason}").write_text(
f"{stop.detail}\n{datetime.now(timezone.utc).isoformat()}\n", "utf-8"
)
except KeyboardInterrupt:
reason = "USER"
ctx.abort.set()
ctx.log("interrupted")
(ctx.run_dir / "STOPPED_USER").write_text("KeyboardInterrupt\n", "utf-8")
return reason
def cmd_run(args: argparse.Namespace) -> int:
gate = cmd_gate_check(args)
if gate and args.claude_bin is None: # only a stand-in claude binary may bypass the gates
return gate
ctx = make_ctx(args)
lock = core.lock_run(ctx.run_dir)
if lock is None:
print(f"run {ctx.run_dir.name} is already running", file=sys.stderr)
return 5
conflicts = resume_conflicts(ctx)
if conflicts: # checked before setup_arms or anything else writes into the run directory
print(f"refusing to resume {ctx.run_dir.name}: {conflicts[:10]}", file=sys.stderr)
return 6
setup_arms(ctx)
torn = core.drop_torn_tail(ctx.results_path)
ctx.log(f"run {ctx.run_dir.name}: arms={ctx.arm_names} tasks={ctx.task_ids}")
if torn:
ctx.log(f"results.jsonl: dropped a {torn}-byte partial last line from an interrupted write")
for flag in (
"DONE",
"STOPPED_TIME",
"STOPPED_BUDGET",
"STOPPED_QUOTA",
"STOPPED_USER",
"STOPPED_DISK",
"STOPPED_AUTH",
"STOPPED_INCOMPLETE_PHASE1",
"STOPPED_COMPRESS",
):
(ctx.run_dir / flag).unlink(missing_ok=True)
hb_stop = start_heartbeat(ctx)
exit_code = 0
def on_signal(signum: int, _frame: Any) -> None:
ctx.abort.set()
raise KeyboardInterrupt(f"signal {signum}")
for sig in (signal.SIGTERM, signal.SIGHUP, signal.SIGINT):
signal.signal(sig, on_signal)
try:
removed = unregister_stale_copies(args.build_dir)
if removed:
ctx.log(f"unregistered stale LaunchServices copies: {removed}")
# The runner owns both private daemons for the run: replace any leftover ones.
stop_agent_daemons(ctx, keep=None)
ca.stop_cua_daemon(ca.RECORDER_SOCKET, ca.RECORDER_STATE / "home")
cua_arms = [a for a in ctx.arm_names if a in ca.CUA_ARMS]
if cua_arms:
ensure_agent_daemon(ctx, cua_arms[0])
start_recorder(ctx)
checks = preflight(ctx, with_models=not args.no_model_preflight)
(ctx.run_dir / "preflight.json").write_text(json.dumps(checks, indent=2) + "\n", "utf-8")
failed = [c for c in checks if c[1] == "fail"]
known = ctx.quota is not None and ctx.quota.get("seven_day") is not None
native_only = all(
a in NO_CLAUDE_SEAT for a in ctx.arm_names
) # Amendment 20: no Claude seat in use
if (
not known
and not native_only
and not args.allow_unknown_quota
and args.claude_bin is None
):
failed.append(
(
"quota reading",
"fail",
"no seven-day utilisation known; refusing to start (--allow-unknown-quota overrides)",
)
)
if failed:
ctx.log(f"preflight failed: {[c[0] for c in failed]}")
(ctx.run_dir / "PREFLIGHT_FAILED").write_text(
json.dumps(failed, indent=2) + "\n", "utf-8"
)
return 2
write_manifest(ctx, core.flat_entries(ctx.blocks())[:6])
reason = run_loop(ctx)
if ctx.compress: # DONE means every video is compressed: drain first
ctx.compress.join()
if reason == "DONE" and not all(map(rec.compressed, map(Path, ctx.compress.results))):
reason = "COMPRESS" # a video has no record; a resume compresses it again
summary = finalize(ctx)
ctx.log(
f"finished: {reason}; blocks complete {summary['blocks_complete']}/{summary['blocks_total']}"
)
(ctx.run_dir / ("DONE" if reason == "DONE" else f"STOPPED_{reason}")).write_text(
json.dumps({"reason": reason, **summary}, indent=2) + "\n", "utf-8"
)
(ctx.run_dir / "done.json").write_text(
json.dumps(
{
"reason": reason,
"ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
**summary,
},
indent=2,
)
+ "\n",
"utf-8",
)
except Exception as error: # noqa: BLE001
ctx.log(f"runner crashed: {type(error).__name__}: {error}")
(ctx.run_dir / "done.json").write_text(
json.dumps({"reason": "CRASH", "error": str(error)}) + "\n", "utf-8"
)
exit_code = 1
finally:
ctx.set_state(state="stopped")
hb_stop.set()
shutdown(ctx)
return exit_code
def cmd_gate_check(args: argparse.Namespace) -> int:
"""No model call: HOLD file and the latest known seven-day reading. Exit 3 gated, 4 held, else 0."""
hold = WORK / "HOLD"
if hold.exists() and not args.ignore_hold:
print(f"HELD: {hold} exists: {hold.read_text('utf-8').strip()[:300]}")
return 4
latest = core.latest_known_quota(QUOTA_LATEST, args.ledger)
decision = core.gate_decision(latest, args.seven_day_stop)
print(f"quota gate: {decision['action'].upper()}: {decision['reason']}")
if latest:
print(
f"latest known: {json.dumps({k: latest.get(k) for k in ('ts', 'five_hour', 'seven_day', 'status', 'source')})}"
)
if decision["action"] == "gated":
arm_names = [args.only_arm] if args.only_arm else list(args.arms)
if arm_names and all(
a in NO_CLAUDE_SEAT for a in arm_names
): # Amendment 20: no Claude seat in use
print("quota gate not applied: only native Codex arms, which use no Claude seat")
return 0
print("RUN GATED: not starting. The seven-day figure only grows until its window resets.")
return 3
return 0
def cmd_preflight(args: argparse.Namespace) -> int:
args.run_id = args.run_id or "preflight"
ctx = make_ctx(args)
lock = core.lock_run(ctx.run_dir)
if lock is None or core.load_rows(
ctx.results_path
): # a run's manifest is what a resume is checked against
print(f"run {ctx.run_dir.name} is a run; preflight under another --run-id", file=sys.stderr)
return 2
setup_arms(ctx)
try:
start_recorder(ctx)
checks = preflight(ctx, with_models=not args.no_model_preflight)
(ctx.run_dir / "preflight.json").write_text(json.dumps(checks, indent=2) + "\n", "utf-8")
write_manifest(
ctx, core.flat_entries(ctx.blocks())[:6]
) # shows every pin the run would record
finally:
shutdown(ctx)
failed = [c for c in checks if c[1] == "fail"]
print(f"\npreflight: {len(checks) - len(failed)} ok/warn, {len(failed)} FAILED")
return 2 if failed else 0
def cmd_dry_run(args: argparse.Namespace) -> int:
ctx = make_ctx(args)
schedule = core.flat_entries(ctx.blocks())
for entry in schedule:
task = ctx.tasks[entry["task"]]
spec = task_spec(task)
print(
json.dumps(
{
**entry,
"seed": core.probe_seed(entry["task"], entry["run_index"]),
"timeout_s": args.timeout_s or spec.get("timeout_s"),
"max_turns": args.max_turns or spec.get("max_turns", 30),
}
)
)
print(
f"{len(schedule)} trials in {len(ctx.blocks())} block(s); tasks={ctx.task_ids}; arms={ctx.arm_names}; "
f"phase1_runs={args.phase1_runs} phase2_runs={args.phase2_runs}"
)
for task_id, arm in ((t, a) for t in ctx.task_ids for a in ctx.arm_names):
if arm in arms.CLAUDE_ARMS:
try:
path, server = ca.mcp_config_for(arm, ctx.run_dir, args.codex_cu_mcp)
argv = ca.claude_argv(
mcp_config=path,
server=server,
model=args.model,
max_turns=args.max_turns or 30,
max_budget_usd=args.max_budget_usd,
tool_search=args.tool_search == "default",
effort=args.effort,
system_prompt=ca.system_prompt_for(
SOURCE_ARM.get(arm, arm),
browser=bool(task_spec(ctx.tasks[task_id]).get("browser")),
),
)
print(
f"\n{task_id} {arm}:\n "
+ " ".join(json.dumps(a) if " " in a else a for a in argv)
)
except (FileNotFoundError, ValueError) as error:
print(f"\n{arm}: UNAVAILABLE ({error})")
return 0
def cmd_status(args: argparse.Namespace) -> int:
run_dir = (args.runs_dir / (args.run_id or "")).resolve()
beat = run_dir / "heartbeat.json"
if beat.exists():
print(beat.read_text("utf-8"))
rows = core.load_rows(run_dir / "results.jsonl")
print(f"{len(rows)} rows; passed {sum(1 for r in rows if r.get('passed'))}")
for flag in sorted(run_dir.glob("STOPPED_*")) + sorted(run_dir.glob("DONE")):
print("flag:", flag.name)
return 0
def cmd_finalize(args: argparse.Namespace) -> int:
ctx = make_ctx(args)
lock = core.lock_run(ctx.run_dir) # finalize rewrites results.jsonl: never under a live run
if lock is None:
print(f"run {ctx.run_dir.name} is running; finalize it after it stops", file=sys.stderr)
return 5
with lock:
print(json.dumps(finalize(ctx), indent=2))
return 0
def main() -> int:
args = build_parser().parse_args()
if args.command == "gate-check":
return cmd_gate_check(args)
if args.command == "preflight":
return cmd_preflight(args)
if args.command == "dry-run":
return cmd_dry_run(args)
if args.command == "status":
return cmd_status(args)
if args.command == "finalize":
return cmd_finalize(args)
return cmd_run(args)
if __name__ == "__main__":
raise SystemExit(main())
#!/usr/bin/env python3
# SPDX-License-Identifier: FSL-1.1-MIT
# Copyright (c) 2026 Cua AI, Inc.
"""Claude Code computer-use benchmark runner: same model, same harness, two MCP tool layers.
run_bench.py preflight --run-id NAME [--build-dir DIR]
run_bench.py dry-run --phase1-runs 3 --phase2-runs 2
run_bench.py run --run-id NAME --build-dir DIR --phase1-runs 3 --phase2-runs 2 \
--cutoff-utc 2026-10-06T03:00:00Z
run_bench.py status --run-id NAME
Arms (run_bench.py never mixes them up with the Codex pilot arms):
cc-cua-driver Claude Code + Cua Driver 0.34.0 MCP + the Cua Driver skill of that release
cc-cua-driver-main the same with Cua Driver built from a pinned main commit and its skill (Amendment 3)
cc-codex-cu Claude Code + Codex computer-use `cua_repl` MCP (server `codex-cu`), no skill
Fallback arms (`codex exec --json`, behind --allow-codex-arms; not run at scale): codex-native-cu,
codex-cua-driver. They reuse run_pilot.py.
Pre-registered rules are in bench_core.py. Per-trial output lives under runs/<run>/trials/<trial id>/.
Run it from a Terminal.app shell (launch_bench.command): the Codex computer-use service refuses
clients whose responsible app cannot show the macOS Automation prompt.
"""
from __future__ import annotations
import argparse
import base64
import contextlib
import hashlib
import json
import math
import os
import platform
import re
import shutil
import signal
import subprocess
import sys
import tempfile
import threading
import time
from dataclasses import dataclass, field
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
sys.path.insert(0, str(HERE / "swift"))
import arms # noqa: E402
import bench_v2 as v2 # noqa: E402
import bench_core as core # noqa: E402
import claude_arms as ca # noqa: E402
import cdb_adapter # noqa: E402
import codex_native as cxn # noqa: E402
import pi_arms as pia # noqa: E402
import browser_use_cli as bu
import claude_driver # noqa: E402
import claude_events # noqa: E402
import recorder as rec # noqa: E402
import run_pilot as pilot # noqa: E402
import desktop_runtime as desktop
from dataclasses import replace
SCHEMA = "cdb-bench-trial/1"
# The Claude Code arm whose driver build, MCP entry, skill and system prompt a Codex or pi arm uses
SOURCE_ARM = {**cxn.SOURCE_ARM, **pia.SOURCE_ARM}
# Arms that use no Claude seat: no quota gate, no Haiku probes
NO_CLAUDE_SEAT = cxn.ARMS + pia.ARMS
WEB_TASKS = ("WEB-01", "WEB-02")
WORK = ca.WORK
DEFAULT_LEDGER = WORK / "ledger" / "spend.jsonl"
DEFAULT_RUNS = WORK / "runs"
DISK_FLOOR_GB = 80.0
PRICE_FALLBACK = { # USD per million tokens, ASSUMED list prices, used only when no total_cost_usd exists
"input": 3.0,
"output": 15.0,
"cache_read": 0.30,
"cache_write": 6.0,
}
class StopRun(Exception):
def __init__(self, reason: str, detail: str = "") -> None:
super().__init__(f"{reason}: {detail}")
self.reason, self.detail = reason, detail
# ---------------------------------------------------------------- tasks
def task_selector_files(probes_dir: Path) -> list[Path]:
"""Selectors of this repository, plus those of the held-out pack when `CDB_TASKPACK_HELDOUT` is set
(`<held-out pack>/probes/<ID>/task.json`, `"split": "heldout"`)."""
files = sorted(probes_dir.glob("*/task.json"))
heldout = os.environ.get("CDB_TASKPACK_HELDOUT")
if heldout:
files += sorted((Path(heldout) / "probes").glob("*/task.json"))