| |
| |
|
|
| """Pure logic for the Claude Code benchmark runner: schedule, quota gate, spend ledger, backoff, |
| wall-clock cutoff and round bookkeeping. No GUI, no model calls, so it is unit-tested. |
| |
| Pre-registered rules implemented here: |
| |
| * Task-major blocks in a fixed priority order, never shuffled. Phase 1: for each task, runs 1-3, each |
| run a pair of back-to-back trials (one per arm). Phase 2 (only after phase 1 is complete for every |
| task and quota allows): for each task, runs 4-5 as a block of 2 pairs. |
| * For the task at 0-based position ``i`` and 0-based run ``r`` the first arm of the pair is |
| ``arms[0]`` when ``(i + r)`` is even and ``arms[1]`` otherwise. Both arms share the run's seed. |
| * A block is the unit of completeness. Only complete blocks are analysed; rows of an interrupted |
| block are kept and flagged ``block_incomplete``. |
| * No dollar cap by default (subscription). ``total_cost_usd`` is recorded as equivalent cost. |
| * Stop starting trials when the 7-day quota reaches 0.95 or a quota event reads "rejected" on |
| the 7-day window. A rejected 5-hour window waits for its reset instead. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import fcntl |
| import json |
| import re |
| import time |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from typing import Any, Iterable |
|
|
| SEVEN_DAY_STOP = 0.95 |
| BACKOFF_BASE_S = 60.0 |
| BACKOFF_CAP_S = 900.0 |
| RESET_WAIT_MAX_S = 3 * 3600.0 |
| OVERLOAD_RETRIES = 3 |
|
|
|
|
| |
|
|
|
|
| def priority_key(task_id: str) -> tuple[int, int, str]: |
| """CDB-* first (primary result), then MB-NN probes in numeric order, anything else after, by name.""" |
| if task_id.startswith("CDB-"): |
| return (0, 0, task_id) |
| match = re.fullmatch(r"MB-(\d+)", task_id) |
| if match: |
| return (1, int(match.group(1)), task_id) |
| return (2, 0, task_id) |
|
|
|
|
| def order_tasks(task_ids: Iterable[str], explicit: bool = False) -> list[str]: |
| ids = list(task_ids) |
| return ids if explicit else sorted(ids, key=priority_key) |
|
|
|
|
| def first_arm_index(task_pos: int, run_index: int, n_arms: int = 2) -> int: |
| """Which arm runs first in the pair for task ``task_pos`` and run ``run_index`` (both 0-based): |
| arms[0] when (task_pos + run_index) is even, else arms[1].""" |
| if n_arms == 2: |
| return 0 if (task_pos + run_index) % 2 == 0 else 1 |
| return (task_pos + run_index) % n_arms |
|
|
|
|
| def arm_order(task_pos: int, run_index: int, arms: list[str]) -> list[str]: |
| start = first_arm_index(task_pos, run_index, len(arms)) |
| return arms[start:] + arms[:start] |
|
|
|
|
| def trial_id(task: str, run_index: int, arm: str) -> str: |
| return f"{task}-r{run_index + 1}-{arm}" |
|
|
|
|
| def block_id(phase: int, task: str) -> str: |
| return f"P{phase}-{task}" |
|
|
|
|
| def build_pair( |
| task_ids: list[str], task: str, run_index: int, arms: list[str], schedule_seed: int, phase: int |
| ) -> list[dict[str, Any]]: |
| """The two trials (one per arm) of one run of one task, in execution order.""" |
| pos = task_ids.index(task) |
| entries = [] |
| for slot, arm in enumerate(arm_order(pos, run_index, arms)): |
| entries.append( |
| { |
| "trial_id": trial_id(task, run_index, arm), |
| "phase": phase, |
| "block": block_id(phase, task), |
| "run_index": run_index, |
| "run": run_index + 1, |
| "task": task, |
| "arm": arm, |
| "task_pos": pos, |
| "arm_slot": slot, |
| "first_arm": slot == 0, |
| "schedule_seed": schedule_seed, |
| } |
| ) |
| return entries |
|
|
|
|
| def build_blocks( |
| task_ids: list[str], arms: list[str], phase1_runs: int, phase2_runs: int, schedule_seed: int |
| ) -> list[dict[str, Any]]: |
| """Task-major blocks. Phase 1: every task in priority order, runs 0..phase1_runs-1, each run a pair of |
| back-to-back trials (one per arm). Phase 2: every task again, the next ``phase2_runs`` runs. A block is |
| the unit of completeness. Order is deterministic; no randomness is used (the seed is only recorded).""" |
| blocks: list[dict[str, Any]] = [] |
| for phase, first, count in ((1, 0, phase1_runs), (2, phase1_runs, phase2_runs)): |
| if count <= 0: |
| continue |
| for task in task_ids: |
| entries: list[dict[str, Any]] = [] |
| for run_index in range(first, first + count): |
| entries.extend(build_pair(task_ids, task, run_index, arms, schedule_seed, phase)) |
| blocks.append( |
| { |
| "id": block_id(phase, task), |
| "phase": phase, |
| "task": task, |
| "runs": list(range(first, first + count)), |
| "entries": entries, |
| } |
| ) |
| index = 0 |
| for block in blocks: |
| for entry in block["entries"]: |
| entry["order_index"] = index |
| index += 1 |
| return blocks |
|
|
|
|
| def flat_entries(blocks: list[dict[str, Any]]) -> list[dict[str, Any]]: |
| return [e for b in blocks for e in b["entries"]] |
|
|
|
|
| def probe_seed(task_id: str, run_index: int) -> int: |
| """Task seed, identical for both arms: sha256(task:run_index) mod 10^6 (as in the pilot).""" |
| import hashlib |
|
|
| digest = hashlib.sha256(f"{task_id}:{run_index}".encode()).hexdigest() |
| return int(digest[:8], 16) % 1_000_000 |
|
|
|
|
| def phase2_allowed(blocks: list[dict[str, Any]], final_ids: set[str], quota_ok: bool) -> bool: |
| """Phase 2 starts only when every phase-1 block is complete and quota allows.""" |
| if not quota_ok: |
| return False |
| return all(e["trial_id"] in final_ids for b in blocks if b["phase"] == 1 for e in b["entries"]) |
|
|
|
|
| def block_status( |
| rows: Iterable[dict[str, Any]], blocks: list[dict[str, Any]] |
| ) -> dict[str, dict[str, Any]]: |
| """Completeness per block: every (run, arm) trial has a final row. Smoke rows are ignored.""" |
| final: dict[str, dict[str, Any]] = {} |
| for row in rows: |
| if row.get("smoke") or not row.get("final", True): |
| continue |
| final[row["trial_id"]] = row |
| out: dict[str, dict[str, Any]] = {} |
| for block in blocks: |
| want = [e["trial_id"] for e in block["entries"]] |
| have = [t for t in want if t in final] |
| out[block["id"]] = { |
| "complete": len(have) == len(want), |
| "n_trials": len(have), |
| "n_expected": len(want), |
| "n_excluded": sum(1 for t in have if final[t].get("excluded")), |
| } |
| return out |
|
|
|
|
| def flag_incomplete( |
| rows: list[dict[str, Any]], blocks: list[dict[str, Any]] |
| ) -> list[dict[str, Any]]: |
| status = block_status(rows, blocks) |
| where = {e["trial_id"]: b["id"] for b in blocks for e in b["entries"]} |
| for row in rows: |
| if row.get("smoke"): |
| row["block_incomplete"] = False |
| continue |
| bid = where.get(row["trial_id"]) |
| row["block"] = bid |
| row["block_incomplete"] = not (bid and status[bid]["complete"]) |
| return rows |
|
|
|
|
| |
|
|
|
|
| def quota_gate( |
| quota: dict[str, Any] | None, seven_day_stop: float = SEVEN_DAY_STOP |
| ) -> dict[str, Any]: |
| """Decide from the latest normalised quota event (see claude_events.quota_from_event). |
| |
| Returns ``{"action": "go" | "stop" | "wait", "reason": str, "wait_until": epoch | None}``. |
| """ |
| if not quota: |
| return {"action": "go", "reason": "no quota data yet", "wait_until": None} |
| seven = quota.get("seven_day") |
| five = quota.get("five_hour") |
| status = quota.get("status") |
| kind = quota.get("type") |
| if seven is not None and seven >= seven_day_stop: |
| return { |
| "action": "stop", |
| "reason": f"seven_day utilization {seven:.3f} >= {seven_day_stop}", |
| "wait_until": None, |
| } |
| if status == "rejected": |
| if kind == "five_hour" and (seven is None or seven < seven_day_stop): |
| return { |
| "action": "wait", |
| "reason": "five_hour window rejected", |
| "wait_until": quota.get("five_hour_resets_at") or quota.get("resets_at"), |
| } |
| return {"action": "stop", "reason": f"quota rejected ({kind})", "wait_until": None} |
| if five is not None and five >= 1.0 and (seven is None or seven < seven_day_stop): |
| return { |
| "action": "wait", |
| "reason": f"five_hour utilization {five:.3f}", |
| "wait_until": quota.get("five_hour_resets_at"), |
| } |
| return {"action": "go", "reason": "ok", "wait_until": None} |
|
|
|
|
| |
|
|
|
|
| def backoff_seconds( |
| attempt: int, base: float = BACKOFF_BASE_S, cap: float = BACKOFF_CAP_S |
| ) -> float: |
| """Exponential backoff: base, 2*base, 4*base ... capped. ``attempt`` is 0-based.""" |
| return min(cap, base * (2 ** max(0, attempt))) |
|
|
|
|
| def wait_seconds( |
| attempt: int, |
| reset_epoch: float | None, |
| now: float | None = None, |
| max_wait: float = RESET_WAIT_MAX_S, |
| ) -> float: |
| """Wait until the reset time when the message carries one (plus a small margin, at most |
| ``max_wait``); otherwise exponential backoff.""" |
| now = time.time() if now is None else now |
| if reset_epoch and reset_epoch > now: |
| return min(max_wait, reset_epoch - now + 30.0) |
| return backoff_seconds(attempt) |
|
|
|
|
| def parse_utc(text: str) -> float: |
| """ISO-8601 -> epoch seconds. A value without a zone is read as UTC.""" |
| value = datetime.fromisoformat(text.strip().replace("Z", "+00:00")) |
| if value.tzinfo is None: |
| value = value.replace(tzinfo=timezone.utc) |
| return value.timestamp() |
|
|
|
|
| def past_cutoff(cutoff_epoch: float | None, now: float | None = None) -> bool: |
| return cutoff_epoch is not None and (time.time() if now is None else now) >= cutoff_epoch |
|
|
|
|
| def block_fits( |
| cutoff_epoch: float | None, |
| est_block_s: float | None, |
| now: float | None = None, |
| margin: float = 1.1, |
| ) -> bool: |
| """For phase-2 blocks: start only if a whole block is expected to finish before the cutoff so a |
| block is not wasted as incomplete. Unknown estimate means do not start.""" |
| if cutoff_epoch is None: |
| return True |
| if not est_block_s: |
| return False |
| now = time.time() if now is None else now |
| return now + est_block_s * margin <= cutoff_epoch |
|
|
|
|
| |
|
|
|
|
| class Ledger: |
| """Shared append-only JSONL ledger of model spend (equivalent cost), safe across processes.""" |
|
|
| def __init__(self, path: Path) -> None: |
| self.path = path |
| self.path.parent.mkdir(parents=True, exist_ok=True) |
|
|
| def append( |
| self, who: str, purpose: str, model: str | None, cost_usd: float | None, **extra: Any |
| ) -> dict[str, Any]: |
| entry = { |
| "ts": datetime.now(timezone.utc).isoformat(timespec="seconds"), |
| "who": who, |
| "purpose": purpose, |
| "model": model, |
| "cost_usd": cost_usd, |
| **extra, |
| } |
| with self.path.open("a", encoding="utf-8") as handle: |
| fcntl.flock(handle, fcntl.LOCK_EX) |
| try: |
| handle.write(json.dumps(entry) + "\n") |
| handle.flush() |
| finally: |
| fcntl.flock(handle, fcntl.LOCK_UN) |
| return entry |
|
|
| def entries(self) -> list[dict[str, Any]]: |
| if not self.path.exists(): |
| return [] |
| out = [] |
| for line in self.path.read_text("utf-8").splitlines(): |
| try: |
| out.append(json.loads(line)) |
| except json.JSONDecodeError: |
| continue |
| return out |
|
|
| def cumulative(self, who: str | None = None) -> float: |
| return round( |
| sum( |
| float(e.get("cost_usd") or 0.0) |
| for e in self.entries() |
| if who is None or e.get("who") == who |
| ), |
| 6, |
| ) |
|
|
|
|
| def budget_allows(cumulative: float, per_trial_cap: float, cap: float | None) -> bool: |
| """Optional dollar gate. ``cap=None`` (the default) never refuses.""" |
| if cap is None: |
| return True |
| return cumulative + per_trial_cap <= cap |
|
|
|
|
| |
|
|
|
|
| def completed_trial_ids(rows: Iterable[dict[str, Any]]) -> set[str]: |
| """Trial ids that are final: a row exists that is not a retryable infra failure awaiting retry.""" |
| done: set[str] = set() |
| for row in rows: |
| if row.get("smoke"): |
| continue |
| if row.get("final", True): |
| done.add(row["trial_id"]) |
| return done |
|
|
|
|
| def load_rows(path: Path) -> list[dict[str, Any]]: |
| if not path.exists(): |
| return [] |
| rows = [] |
| for line in path.read_text("utf-8").splitlines(): |
| try: |
| rows.append(json.loads(line)) |
| except json.JSONDecodeError: |
| continue |
| return rows |
|
|
|
|
| |
|
|
|
|
| PIN_INFO_KEYS = ( |
| "release", |
| "cua_driver_git_sha", |
| "cua_driver_tarball", |
| "cua_skills_tarball", |
| ) |
|
|
|
|
| def compare_pins( |
| expected: dict[str, Any], observed: dict[str, Any] |
| ) -> list[tuple[str, Any, Any, bool]]: |
| """One row per expected pin: (name, expected, observed, matches). A pin that was not observed fails.""" |
| rows = [] |
| for key, want in expected.items(): |
| if key.startswith("_") or key in PIN_INFO_KEYS: |
| continue |
| got = observed.get(key) |
| rows.append((key, want, got, got == want)) |
| return rows |
|
|
|
|
| |
|
|
|
|
| def persist_quota(path: Path, quota: dict[str, Any], source: str) -> None: |
| """Remember the latest quota reading so the launcher can gate without a model call.""" |
| path.parent.mkdir(parents=True, exist_ok=True) |
| keep = { |
| k: quota.get(k) |
| for k in ( |
| "five_hour", |
| "seven_day", |
| "status", |
| "type", |
| "five_hour_resets_at", |
| "seven_day_resets_at", |
| "resets_at", |
| ) |
| } |
| keep.update(ts=datetime.now(timezone.utc).isoformat(timespec="seconds"), source=source) |
| tmp = path.with_suffix(".tmp") |
| tmp.write_text(json.dumps(keep, indent=2) + "\n", "utf-8") |
| tmp.replace(path) |
|
|
|
|
| def latest_known_quota(latest_path: Path, ledger_path: Path) -> dict[str, Any] | None: |
| """The most recent seven-day reading from quota_latest.json or from ledger entries that carry |
| ``seven_day_after``. Returns None when nothing is known.""" |
| candidates: list[dict[str, Any]] = [] |
| if latest_path.exists(): |
| try: |
| data = json.loads(latest_path.read_text("utf-8")) |
| if data.get("seven_day") is not None: |
| candidates.append(data) |
| except json.JSONDecodeError: |
| pass |
| if ledger_path.exists(): |
| for line in ledger_path.read_text("utf-8").splitlines(): |
| try: |
| entry = json.loads(line) |
| except json.JSONDecodeError: |
| continue |
| if entry.get("seven_day_after") is not None: |
| candidates.append( |
| { |
| "ts": entry["ts"], |
| "seven_day": entry["seven_day_after"], |
| "five_hour": None, |
| "source": f"ledger:{entry.get('purpose', '')[:40]}", |
| } |
| ) |
| if not candidates: |
| return None |
| return max(candidates, key=lambda c: c.get("ts", "")) |
|
|
|
|
| def gate_decision( |
| latest: dict[str, Any] | None, stop: float = SEVEN_DAY_STOP, now: float | None = None |
| ) -> dict[str, Any]: |
| """Launch gate from the latest known quota. The seven-day figure only grows until its reset, so a |
| reading at or above ``stop`` blocks the launch until the window has reset.""" |
| now = time.time() if now is None else now |
| if not latest or latest.get("seven_day") is None: |
| return { |
| "action": "unknown", |
| "reason": "no quota reading on file; the runner's preflight probes the quota itself", |
| } |
| seven = float(latest["seven_day"]) |
| resets = latest.get("seven_day_resets_at") or latest.get("resets_at") |
| window_over = bool(resets and float(resets) < now and latest.get("status") != "rejected") |
| if seven >= stop and not window_over: |
| until = ( |
| datetime.fromtimestamp(float(resets), timezone.utc).isoformat(timespec="minutes") |
| if resets |
| else "unknown" |
| ) |
| return { |
| "action": "gated", |
| "seven_day": seven, |
| "as_of": latest.get("ts"), |
| "reason": f"seven_day utilization {seven:.3f} >= {stop} as of {latest.get('ts')}; window resets {until}", |
| } |
| if window_over: |
| return { |
| "action": "unknown", |
| "reason": f"last reading ({seven:.3f}) is from a window that has reset; the runner will probe", |
| } |
| return { |
| "action": "go", |
| "seven_day": seven, |
| "as_of": latest.get("ts"), |
| "reason": f"seven_day utilization {seven:.3f} < {stop} as of {latest.get('ts')}", |
| } |
|
|
