| """One isolated agent session: a CLI and model rebuilding one benchmark item (a room, an object or a demonstration's |
| scene) in Docker, over one or more budgets, under the item's contract (generation.contracts). |
| |
| Budgets are cumulative. `900 1800` tells the agent 15 minutes, keeps what it made at the stop as the 15-minute result, |
| then resumes the same conversation with the rest of the 30 minutes. Each budget is its own run folder, |
| data/runs/<track>/<engine>/<item>/<UTC time>/. Only the public input, the contract's tools, the output, scratch and |
| temporary credentials enter the container; its only network exit is the egress proxy. |
| |
| simready generate --track scenes --engine mujoco --id 41159420 --cli codex --model gpt-6.1-sol --budget 900 1800 |
| simready generate --track objects --engine mujoco --id input_2d_001 --cli claude --claude-config-dir ~/.claude-huan --model claude-opus-5-5 |
| simready generate --track demos --engine isaac --id ID --cli opencode --model opencode-go/kimi-k3.1-pro --gpu GPU-... |
| """ |
| from datetime import datetime, timedelta, timezone |
| import fcntl |
| import json |
| import os |
| from pathlib import Path |
| import re |
| import shlex |
| import shutil |
| import subprocess |
| import tempfile |
| import time |
|
|
| import imageio_ffmpeg |
|
|
| from ..common.io import DATA, REPO_ROOT |
| from . import contracts |
| from .contracts import EGRESS_HOSTS, IMAGES |
| from .cost import combine_costs, events, keep_codex_usage, keep_opencode_usage, run_cost |
| from .stage import contract_for, frozen_protocol, item_input, stage |
| from .opencode_auth import OpenCodeLogin |
| from .quota import opencode_limit |
|
|
| MUJOCO_IMAGE, ISAAC_IMAGE = IMAGES["mujoco"], IMAGES["isaac"] |
| RUNS, RUNTIME = DATA / "runs", DATA / "runtime" |
| ISAAC_USER = "1234:1234" |
| |
| |
| CLAUDE_AGENT = ["/usr/local/bin/claude", "-p", "--verbose", "--include-partial-messages", "--output-format", "stream-json", |
| "--safe-mode", "--setting-sources", "", "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}', |
| "--disable-slash-commands", "--dangerously-skip-permissions", "--disallowedTools", "WebFetch"] |
| CODEX_FLAGS = ["--json", "--ignore-user-config", "--ignore-rules", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox", |
| "-c", 'web_search="live"', "--disable", "browser_use", "--disable", "browser_use_external", "--disable", "in_app_browser"] |
| |
| |
| |
| |
| OPENCODE = "/opt/opencode/bin/opencode" |
| OPENCODE_FLAGS = ["run", "--pure", "--auto", "--format", "json"] |
| OPENCODE_CONFIG = {"$schema": "https://opencode.ai/config.json", "permission": {"webfetch": "deny"}, "share": "disabled", "autoupdate": False} |
| OPENCODE_ENV = {"XDG_DATA_HOME": "/auth", "XDG_CONFIG_HOME": "/auth/config", "XDG_CACHE_HOME": "/auth/cache", "XDG_STATE_HOME": "/auth/state", |
| "OPENCODE_CONFIG_CONTENT": json.dumps(OPENCODE_CONFIG, separators=(",", ":")), |
| **{f"OPENCODE_DISABLE_{name}": "1" for name in ("AUTOUPDATE", "MODELS_FETCH", "DEFAULT_PLUGINS", "LSP_DOWNLOAD", "PROJECT_CONFIG", |
| "CLAUDE_CODE", "EXTERNAL_SKILLS")}} |
| OPENCODE_DATA = "opencode" |
| EGRESS_NETWORK, EGRESS_PROXY = "simready-egress", "simready-egress-proxy" |
| EGRESS_URL = f"http://{EGRESS_PROXY}:3128" |
| EGRESS_ENV = {"HTTPS_PROXY": EGRESS_URL, "HTTP_PROXY": EGRESS_URL, "https_proxy": EGRESS_URL, "http_proxy": EGRESS_URL, |
| "NO_PROXY": "localhost,127.0.0.1", "no_proxy": "localhost,127.0.0.1", "DISABLE_TELEMETRY": "1", "DISABLE_ERROR_REPORTING": "1"} |
| LOGIN_SYNC_SECONDS = 20 |
| STOP_SECONDS = 300 |
| STALL_SECONDS = 300 |
| MODEL_OUTPUT = {"claude": {"assistant"}, "codex": {"item.started", "item.completed", "turn.completed"}, "opencode": {"step_finish", "text", "tool_use"}} |
|
|
|
|
| def ensure_egress(network=EGRESS_NETWORK, proxy=EGRESS_PROXY, hosts=EGRESS_HOSTS): |
| """The internal network and its proxy, created once and shared by every session (a lock keeps parallel sessions apart).""" |
| def docker(*arguments): |
| return subprocess.run(["docker", *arguments], capture_output=True, text=True) |
| with (Path(tempfile.gettempdir()) / "simready-egress.lock").open("a") as lock: |
| fcntl.flock(lock, fcntl.LOCK_EX) |
| if docker("network", "inspect", network).returncode: |
| docker("network", "create", "--internal", network) |
| state = docker("inspect", "-f", "{{.State.Running}} {{index .Config.Labels \"simready.egress\"}}", proxy).stdout.split() |
| if state != ["true", ",".join(hosts)]: |
| docker("rm", "-f", proxy) |
| started = docker("run", "-d", "--name", proxy, "--restart", "unless-stopped", "--label", "simready.egress=" + ",".join(hosts), |
| "--read-only", "--cap-drop", "ALL", "--user", "65534:65534", "--network", "bridge", |
| "--mount", f"type=bind,src={contracts.RUNTIME / 'egress_proxy.py'},dst=/proxy.py,readonly", |
| MUJOCO_IMAGE, "python", "/proxy.py", "--allow", ",".join(hosts)) |
| if started.returncode: |
| raise RuntimeError(f"egress proxy did not start: {started.stderr.strip()}") |
| docker("network", "connect", network, proxy) |
| return EGRESS_URL |
|
|
|
|
| def save_record(path, record): |
| temporary = path.with_suffix(".tmp") |
| temporary.write_text(json.dumps(record, indent=2) + "\n") |
| temporary.replace(path) |
|
|
|
|
| |
|
|
| def persist_rotated(original, fresh, initial, name, valid): |
| """Keep a CLI's token rotation without overwriting a login that changed meanwhile.""" |
| data = (fresh / name).read_bytes() |
| if data == initial: |
| return "unchanged" |
| if not valid(json.loads(data)): |
| return "invalid_refresh_not_persisted" |
| with (original / ".benchmark-auth.lock").open("a") as lock: |
| fcntl.flock(lock, fcntl.LOCK_EX) |
| backups = original / "credential-backups" |
| backups.mkdir(mode=0o700, exist_ok=True) |
| descriptor = os.open(backups / (datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ") + ".json"), os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600) |
| with os.fdopen(descriptor, "wb") as stream: |
| stream.write(data) |
| canonical = original / name |
| if canonical.read_bytes() != initial: |
| return "backup_saved_concurrent_login_preserved" |
| with tempfile.NamedTemporaryFile("wb", dir=original, delete=False) as stream: |
| stream.write(data) |
| Path(stream.name).replace(canonical) |
| return "refreshed_credentials_persisted" |
|
|
|
|
| def persist_claude(original, fresh, initial): |
| def valid(content): |
| credential = content.get("claudeAiOauth", {}) |
| return all(credential.get(k) for k in ["accessToken", "refreshToken", "expiresAt"]) |
| return persist_rotated(original, fresh, initial, ".credentials.json", valid) |
|
|
|
|
| def persist_codex(original, fresh, initial): |
| return persist_rotated(original, fresh, initial, "auth.json", |
| lambda content: content.get("tokens", {}).get("access_token") or content.get("OPENAI_API_KEY")) |
|
|
|
|
| def persist_opencode(original, fresh, initial): |
| """OpenCode's auth.json: one entry per provider, an API key ("key") or an OAuth pair ("access", "refresh").""" |
| return persist_rotated(original, fresh, initial, "auth.json", |
| lambda content: bool(content) and all(isinstance(v, dict) and (v.get("key") or v.get("access") and v.get("refresh")) |
| for v in content.values())) |
|
|
|
|
| |
|
|
| def session_identity(cli, log): |
| """The CLI's own session id, which a later budget resumes.""" |
| for event in events(log, 30): |
| if cli == "opencode" and event.get("sessionID"): |
| return event["sessionID"] |
| if cli == "codex" and event.get("type") == "thread.started": |
| return event.get("thread_id") |
| if cli == "claude" and event.get("subtype") == "init": |
| return event.get("session_id") |
| return None |
|
|
|
|
| def model_answered(cli, log): |
| """Has the model produced anything yet? A CLI's start-up events (Claude's init, Codex's thread) do not count.""" |
| return any(event.get("type") in MODEL_OUTPUT[cli] for event in events(log)) |
|
|
|
|
| def throttling(log): |
| """Throttling shrinks an agent's real working time, so it is reported with the result.""" |
| retries = limited = 0 |
| for event in events(log): |
| retries += event.get("subtype") == "api_retry" |
| if event.get("type") == "rate_limit_event": |
| limited += (event.get("rate_limit_info") or {}).get("status") not in {"allowed", "allowed_warning"} |
| elif event.get("type") == "error": |
| error = event.get("error") or {} |
| if isinstance(error, dict): |
| data = error.get("data") or {} |
| limited += isinstance(data, dict) and data.get("statusCode") == 429 |
| return {"api_retries": retries, "rate_limit_events": limited} |
|
|
|
|
| def new_run(root, track, engine, item): |
| """A run folder named by the time, taking the next second if a parallel session has this one.""" |
| now = datetime.now(timezone.utc) |
| while True: |
| rid = now.strftime("%Y%m%dT%H%M%SZ") |
| run = Path(root) / track / engine / item / rid |
| try: |
| run.mkdir(parents=True) |
| return rid, run |
| except FileExistsError: |
| now += timedelta(seconds=1) |
|
|
|
|
| def shown(path): |
| return path.relative_to(REPO_ROOT) if path.is_relative_to(REPO_ROOT) else path |
|
|
|
|
| def change_owner(directory, owner): |
| subprocess.run(["docker", "run", "--rm", "--user", "0:0", "--entrypoint", "bash", "--mount", f"type=bind,src={directory},dst=/d", |
| ISAAC_IMAGE, "-lc", "chown -R " + owner + " /d"], check=True, stdout=subprocess.DEVNULL) |
|
|
|
|
| def login_folder(cli, claude_config_dir=None): |
| if cli == "opencode": |
| return Path.home() / ".local/share/opencode" |
| if cli == "codex": |
| return Path.home() / ".codex" |
| return Path(claude_config_dir).expanduser() if claude_config_dir else Path.home() / ".claude" |
|
|
|
|
| def isaac_preflight(cli): |
| """Isaac Sim's shader cache volume per CLI family, warmed once by a GPU render (docs/generation.md).""" |
| return RUNTIME / "isaac" / f"smoke_{cli}" / "smoke.json" |
|
|
|
|
| class Session: |
| def __init__(self, track, engine, item, cli, model, effort=None, gpu=None, claude_config_dir=None, campaign="", runs_root=None): |
| if cli not in contracts.CLIS: |
| raise SystemExit(f"Unknown CLI {cli}; one of {', '.join(contracts.CLIS)}.") |
| |
| self.effort = effort or ("default" if cli == "opencode" else "medium") |
| self.track, self.engine, self.item, self.cli, self.model, self.gpu = track, engine, item, cli, model, gpu |
| self.campaign, self.runs_root = campaign, Path(runs_root).resolve() if runs_root else RUNS |
| self.isaac = engine == "isaac" |
| self.login = login_folder(cli, claude_config_dir) |
| self.claude_config_dir = self.login if cli == "claude" else None |
| self.auth_name = "auth.json" if cli in ("codex", "opencode") else ".credentials.json" |
| self.session_id = None |
| item_input(track, item) |
| self.contract = contract_for(track, engine, item) |
| if contracts.missing_files(self.contract): |
| raise SystemExit(f"{self.contract} stages {', '.join(contracts.missing_files(self.contract))}, not present yet.") |
| if cli == "opencode": |
| self.opencode_login = OpenCodeLogin(self.login, model.split("/", 1)[0]) |
| try: |
| self.read_login() |
| except (OSError, RuntimeError) as error: |
| raise SystemExit(f"OpenCode login is unavailable: {error}") from None |
| elif not (self.login / self.auth_name).is_file(): |
| raise SystemExit(f"The {cli} login is unavailable ({self.login / self.auth_name}).") |
| if self.isaac and not gpu: |
| raise SystemExit("Isaac generation needs a GPU (--gpu UUID).") |
| if self.isaac and not (isaac_preflight(cli).is_file() and json.loads(isaac_preflight(cli).read_text()).get("success")): |
| raise SystemExit(f"Complete the Isaac GPU/render preflight first ({shown(isaac_preflight(cli))}; docs/generation.md).") |
|
|
| @property |
| def held(self): |
| """Where the login sits in the state folder (and under /auth in the container).""" |
| return f"{OPENCODE_DATA}/{self.auth_name}" if self.cli == "opencode" else self.auth_name |
|
|
| def persist(self, original, state, initial): |
| """Save a refreshed login from the state folder back to the CLI's own login.""" |
| if self.cli == "opencode": |
| login = getattr(self, "opencode_login", None) |
| if login is not None and login.v2: |
| return login.persist(state / self.held, initial) |
| return persist_opencode(original, state / OPENCODE_DATA, initial) |
| return (persist_codex if self.cli == "codex" else persist_claude)(original, state, initial) |
|
|
| def read_login(self): |
| login = getattr(self, "opencode_login", None) |
| return login.read() if login is not None else (self.login / self.auth_name).read_bytes() |
|
|
| def agent(self): |
| if self.cli == "opencode": |
| variant = ["--variant", self.effort] if self.effort != "default" else [] |
| return [OPENCODE, *OPENCODE_FLAGS, "-m", self.model, *variant, *(["-s", self.session_id] if self.session_id else [])] |
| if self.cli == "codex": |
| flags = ["-m", self.model, "-c", "model_reasoning_effort=" + json.dumps(self.effort)] + CODEX_FLAGS |
| start = ["exec", "resume", *flags, self.session_id, "-"] if self.session_id else ["exec", *flags, "-C", "/work", "-"] |
| return ["/opt/codex/bin/codex", "--no-daemon", *start] |
| return [*CLAUDE_AGENT, "--model", self.model, "--effort", self.effort, *(["--resume", self.session_id] if self.session_id else [])] |
|
|
| def docker(self, name, public, output, state, scratch): |
| command = ["docker", "run", "--rm", "-i", "--name", name, "--label", f"simready.campaign={self.campaign}", "--cap-drop", "ALL", |
| "--security-opt", "no-new-privileges", "--workdir", "/work", |
| "--network", EGRESS_NETWORK, *[part for key, value in EGRESS_ENV.items() for part in ("-e", f"{key}={value}")], |
| "--mount", f"type=bind,src={public},dst=/work/input,readonly", "--mount", f"type=bind,src={output},dst=/work/output", |
| "--mount", f"type=bind,src={state},dst=/auth", "--mount", f"type=bind,src={scratch},dst=/tmp"] |
| if (public.parent / "tools").is_dir(): |
| command += ["--mount", f"type=bind,src={public.parent / 'tools'},dst=/work/tools,readonly"] |
| if self.isaac: |
| command += ["--gpus", "device=" + self.gpu, "--user", ISAAC_USER, "--pids-limit", "2048", "--memory", "48g", "--cpus", "12", "--shm-size", "2g", |
| "--entrypoint", "bash", "-e", "ACCEPT_EULA=Y", "-e", "NVIDIA_DRIVER_CAPABILITIES=all", |
| "--mount", f"type=bind,src={imageio_ffmpeg.get_ffmpeg_exe()},dst=/usr/local/bin/ffmpeg,readonly", |
| "--mount", f"type=volume,src=simready-isaac-{self.cli}-cache,dst=/isaac-sim/.cache"] |
| else: |
| command += ["--user", f"{os.getuid()}:{os.getgid()}", "--pids-limit", "512", "--memory", "12g", "--cpus", "4", "--read-only", |
| "-e", "HOME=/tmp/agent-home"] |
| if self.cli == "opencode": |
| command += [part for key, value in OPENCODE_ENV.items() for part in ("-e", f"{key}={value}")] |
| elif self.cli == "codex": |
| command += ["-e", "CODEX_HOME=/auth", "-e", "PATH=/opt/codex/bin:/usr/local/bin:/usr/local/sbin:/usr/sbin:/usr/bin:/sbin:/bin"] |
| else: |
| binary = (Path.home() / ".local/bin/claude").resolve() |
| command += ["-e", "CLAUDE_CONFIG_DIR=/auth", "-e", "DISABLE_AUTOUPDATER=1", "--mount", f"type=bind,src={binary},dst=/usr/local/bin/claude,readonly"] |
| shell = "" if self.isaac else "mkdir -p /tmp/agent-home && " |
| return command + [ISAAC_IMAGE if self.isaac else MUJOCO_IMAGE, *(["-lc"] if self.isaac else ["bash", "-c"]), shell + "exec " + shlex.join(self.agent())] |
|
|
| def sync_login(self, name, known): |
| """Refresh tokens rotate: a login refreshed in this container reaches the saved login at once, and one refreshed by |
| another session sharing the login reaches this container, or sessions sharing a login invalidate each other. |
| Returns what both now hold.""" |
| try: |
| held = subprocess.run(["docker", "exec", name, "cat", "/auth/" + self.held], capture_output=True, timeout=15, check=True).stdout |
| saved = self.read_login() |
| if held and held != known: |
| with tempfile.TemporaryDirectory() as directory: |
| fresh = Path(directory) |
| (fresh / self.held).parent.mkdir(parents=True, exist_ok=True) |
| (fresh / self.held).write_bytes(held) |
| (fresh / self.held).chmod(0o600) |
| self.persist(self.login, fresh, known) |
| return self.read_login() |
| if saved != known: |
| subprocess.run(["docker", "exec", "-i", name, "sh", "-c", f"cat > /auth/{self.held}.new && mv /auth/{self.held}.new /auth/{self.held}"], |
| input=saved, capture_output=True, timeout=15, check=True) |
| return saved |
| except (subprocess.SubprocessError, OSError, ValueError, RuntimeError): |
| pass |
| return known |
|
|
| def stage(self, run, record, prompt, seconds, state, scratch): |
| """One timed container. Stopping at the budget is normal; the agent's session survives in `state`.""" |
| public, output, log = run / "input", run / "output", run / "generation.jsonl" |
| initial = self.read_login() |
| (state / self.held).parent.mkdir(mode=0o700, exist_ok=True) |
| (state / self.held).write_bytes(initial) |
| (state / self.held).chmod(0o600) |
| if self.cli == "claude": |
| config = self.login / ".claude.json" |
| config = config if config.is_file() else Path.home() / ".claude.json" |
| content = json.loads(config.read_text()) |
| (state / ".claude.json").write_text(json.dumps({k: content[k] for k in ("oauthAccount", "hasCompletedOnboarding", "installMethod") if k in content})) |
| if self.isaac: |
| for directory in (state, output, scratch): |
| change_owner(directory, ISAAC_USER) |
| name = re.sub(r"[^a-zA-Z0-9_.-]", "-", f"simready-gen-{self.track}-{self.engine}-{self.item}-{run.name.lower()}") |
| started = time.monotonic() |
| record.update(status="running", started_at=datetime.now(timezone.utc).isoformat()) |
| save_record(run / "run.json", record) |
| guard = getattr(self, "quota_guard", None) |
| if guard: |
| reason = guard.reason(self.cli) |
| if reason: |
| log.touch() |
| record.update(status="quota_paused", quota_pause_reason=reason, |
| api_retries=0, rate_limit_events=0, exit_code=None, |
| credential_refresh_persistence="unchanged", cli_session_id=self.session_id, |
| finished_at=datetime.now(timezone.utc).isoformat()) |
| return 0. |
| try: |
| with log.open("w") as stream: |
| ensure_egress() |
| process = subprocess.Popen(self.docker(name, public, output, state, scratch), stdin=subprocess.PIPE, stdout=stream, |
| stderr=subprocess.STDOUT, text=True, start_new_session=True) |
| process.stdin.write(prompt) |
| process.stdin.close() |
| try: |
| while True: |
| try: |
| process.wait(timeout=min(LOGIN_SYNC_SECONDS, max(seconds - (time.monotonic() - started), .1))) |
| break |
| except subprocess.TimeoutExpired: |
| reason = guard.reason(self.cli) if guard else None |
| if guard and self.cli == "opencode" and guard.config.get("opencode_pause_on_limit"): |
| reason = reason or opencode_limit(log) |
| if reason: |
| guard.pause(self.cli, reason) |
| if reason: |
| record["quota_pause_reason"] = reason |
| raise |
| if time.monotonic() - started >= seconds: |
| raise |
| if not record.get("model_answered"): |
| record["model_answered"] = model_answered(self.cli, log) |
| if not record["model_answered"] and time.monotonic() - started >= STALL_SECONDS: |
| record["stalled"] = True |
| raise |
| initial = self.sync_login(name, initial) |
| record.update(status="completed" if process.returncode == 0 else "cli_failed", exit_code=process.returncode) |
| except subprocess.TimeoutExpired: |
| subprocess.run(["docker", "kill", name], capture_output=True) |
| try: |
| process.wait(timeout=STOP_SECONDS) |
| except subprocess.TimeoutExpired: |
| process.kill() |
| process.wait() |
| record.update(status="quota_paused" if record.get("quota_pause_reason") else |
| "cli_failed" if record.get("stalled") else "budget_expired", exit_code=process.returncode) |
| finally: |
| subprocess.run(["docker", "rm", "-f", name], capture_output=True) |
| if self.isaac: |
| for directory in (state, output, scratch): |
| change_owner(directory, f"{os.getuid()}:{os.getgid()}") |
| record["credential_refresh_persistence"] = self.persist(self.login, state, initial) |
| record["finished_at"] = datetime.now(timezone.utc).isoformat() |
| self.session_id = self.session_id or session_identity(self.cli, log) |
| record["cli_session_id"] = self.session_id |
| record.update(throttling(log)) |
| if guard and self.cli == "opencode" and guard.config.get("opencode_pause_on_limit"): |
| reason = opencode_limit(log) |
| if reason: |
| guard.pause(self.cli, reason) |
| record.update(status="quota_paused", quota_pause_reason=reason) |
| if record.get("stalled"): |
| record["rate_limit_events"] = max(1, record["rate_limit_events"]) |
| return time.monotonic() - started |
|
|
| def run(self, budgets, on_result=None): |
| """Run every budget; `on_result(run, record)` is called as each result is ready to evaluate.""" |
| rows, used, previous, earlier_cost = [], 0., None, None |
| protocol = frozen_protocol(self.track, self.engine) |
| if not protocol.is_file(): |
| print(f"warning: {shown(protocol)} is not frozen yet; the run records protocol sha256 null", flush=True) |
| (RUNTIME / "session_scratch").mkdir(parents=True, exist_ok=True) |
| with tempfile.TemporaryDirectory(prefix="simready-session-") as directory, tempfile.TemporaryDirectory(dir=RUNTIME / "session_scratch") as scratch: |
| state = Path(directory) |
| state.chmod(0o700) |
| Path(scratch).chmod(0o777) |
| try: |
| for budget in budgets: |
| if budget - used <= 0: |
| break |
| rid, run = new_run(self.runs_root, self.track, self.engine, self.item) |
| if previous is None: |
| (run / "output").mkdir() |
| else: |
| shutil.copytree(previous / "output", run / "output", symlinks=True) |
| (run / "output").chmod(0o777) |
| _, first = stage(self.track, self.engine, self.item, run, budgets[0], self.cli) |
| prompt = first if previous is None else contracts.resume_text(budgets[len(rows) - 1], budget - used) |
| (run / "submitted_prompt.txt").write_text(prompt) |
| contract = contracts.record(self.contract) |
| record = {"track": self.track, "engine": self.engine, "item": self.item, "run_id": rid, "campaign": self.campaign, |
| "cli": self.cli, "model": self.model, "model_reasoning_effort": self.effort, |
| "budget_seconds": budget, "told_budget_seconds": budgets[0], "stage": len(rows) + 1, |
| "continued_from": previous.name if previous else None, "contract": contract, |
| "engine_version": contract["engine_version"], "image": contract["image"], |
| "image_id": subprocess.check_output(["docker", "image", "inspect", contract["image"], "--format", "{{.Id}}"], text=True).strip(), |
| "required_refinement_rounds": (contract["refinement"] or {}).get("minimum_completed_rounds"), "gpu_uuid": self.gpu, |
| "input_snapshot": "input", "tools": "tools" if (run / "tools").is_dir() else None, |
| "evaluator_protocol": "evaluator_protocol.json" if (run / "evaluator_protocol.json").is_file() else None, |
| "output": "output", "log": "generation.jsonl", "status": "preparing", |
| "agent_cli": contracts.cli_record(self.cli, self.model, self.claude_config_dir)} |
| save_record(run / "run.json", record) |
| print(f"Run: {shown(run)}", flush=True) |
| record["stage_seconds"] = round(self.stage(run, record, prompt, budget - used, state, Path(scratch)), 3) |
| used += record["stage_seconds"] |
| record["elapsed_seconds"] = round(used, 3) |
| if self.cli == "codex": |
| keep_codex_usage(state, run) |
| if self.cli == "opencode": |
| keep_opencode_usage(state / OPENCODE_DATA, run) |
| cost = run_cost(run, record) |
| record["cost"] = combine_costs(earlier_cost, cost) if self.cli == "claude" else cost |
| earlier_cost = record["cost"] |
| record["scene_present"] = any((run / "output" / name).is_file() for name in ("scene.xml", "scene.usda", "scene.usd")) |
| save_record(run / "run.json", record) |
| rows.append(run) |
| previous = run |
| if on_result: |
| on_result(run, record) |
| if record["status"] in {"cli_failed", "quota_paused"} or not self.session_id: |
| break |
| finally: |
| if self.isaac: |
| change_owner(scratch, f"{os.getuid()}:{os.getgid()}") |
| return rows |
|
|
