#!/usr/bin/env python3 """Closed LIBERO/SimplerEnv/RoboCasa365/SIMPLE artifact audit; never runs a simulator. The caller explicitly supplies the one closed mailbox. This is evidence checking, not actor isolation, native scoring, model metering or leaderboard certification. """ from __future__ import annotations import argparse import hashlib import io import json import math from fractions import Fraction from pathlib import Path from benchkit.audits.closed_run import ClosedFiles, audit_run, require PUBLIC_FIELDS = {"schema_version", "request_id", "step", "instruction", "images", "state", "observation_spec", "action_spec", "budgets", "prompt", "history"} PUBLIC_FIELDS_V3 = PUBLIC_FIELDS | {"policy_constraints", "control_feedback"} IMAGE_FIELDS = {"path", "encoding", "color_space", "width", "height", "sha256"} ROBOCASA_CAMERAS = ["robot0_agentview_left", "robot0_agentview_right", "robot0_eye_in_hand"] SIMPLE_HEAD_CAMERAS = {"head_stereo_left", "head_stereo_right"} SIMPLE_ALL_CAMERAS = SIMPLE_HEAD_CAMERAS | {"front_stereo_left", "front_stereo_right"} def audit_policy_fields(public: dict, version: str, parameters: dict, protocol: dict, feedback: dict) -> None: """Check declared policy-only settings and counter receipts, without media. Old v2 keeps its historical field set; it is never relabeled v3. This helper checks record consistency only, not trusted enforcement by an external actor. """ require(version in {"starvla-rsi.mailbox/v2", "starvla-rsi.mailbox/v3"}, "unsupported mailbox schema") require(set(public) == (PUBLIC_FIELDS_V3 if version.endswith("/v3") else PUBLIC_FIELDS), "unexpected public observation fields") require(public["schema_version"] == version, "public policy schema drift") if version.endswith("/v2"): return require(protocol.get("execution_feedback_version") == "starvla-rsi.execution-feedback/v1", "mailbox v3 requires declared execution receipts") require(not {"min_action_decisions_before_give_up", "stop_constraint_version", "early_policy_stop_exception"} & set(protocol), "policy persistence must not be mixed into benchmark protocol") rule = parameters.get("policy_stop_rule") require(isinstance(rule, dict) and set(rule) == { "stop_constraint_version", "min_action_decisions_before_give_up", "early_policy_stop_exception", "scope"}, "invalid policy persistence declaration") minimum = rule["min_action_decisions_before_give_up"] require(type(minimum) is int and minimum >= 0 and rule["stop_constraint_version"] == "minimum-action-decisions/v2" and rule["early_policy_stop_exception"] == "safety_stop_with_nonempty_note" and rule["scope"] == "policy", "unknown policy persistence declaration") received = public["control_feedback"] require(isinstance(received, dict) and set(received) == set(feedback) and all(type(value) is int and value >= 0 for value in received.values()) and received == feedback, "policy execution feedback differs from actual controls") expected = {**rule, "voluntary_stop_allowed": feedback["action_decisions"] >= minimum} require(public["policy_constraints"] == expected and type(public["policy_constraints"].get("voluntary_stop_allowed")) is bool and type(public["policy_constraints"].get("min_action_decisions_before_give_up")) is int, "public policy persistence configuration drift") def bound_reference(files: ClosedFiles, reference: str) -> str: """Accept only explicit absolute references inside the caller-authorized root.""" path = Path(reference) require(path.is_absolute() and ".." not in path.parts, "unsafe absolute reference") require(path.is_relative_to(files.root), "reference outside authorized root") relative = path.relative_to(files.root).as_posix() files.path(relative) # Includes symlink and missing-file rejection. return relative def png(files: ClosedFiles, relative: str, expected_hash: str): from PIL import Image payload = files.raw(relative) require(files.hashes[relative] == expected_hash, "PNG digest mismatch") with Image.open(io.BytesIO(payload)) as decoded: require(decoded.format == "PNG" and decoded.mode == "RGB", "non-RGB PNG") decoded.load() return decoded.copy() def stream_hash(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as source: for block in iter(lambda: source.read(1024 * 1024), b""): digest.update(block) return digest.hexdigest() def audit_video(files: ClosedFiles, relative: str, rows: list, frame_base: Path, *, expected_hz: int | None = None) -> dict: import av import numpy as np path = files.path(relative) digest = stream_hash(path) count = flat_frames = 0 differences = [] dimensions = None with av.open(str(path)) as container: require(len(container.streams.video) == 1, "video must have one video stream") for frame in container.decode(video=0): require(count < len(rows), "video has extra frames") if expected_hz is not None: require(frame.pts is not None and frame.time_base is not None and frame.pts * frame.time_base == Fraction(count, expected_hz), "video presentation timestamp differs from native control time") row = rows[count] expected = png(files, (frame_base / row["path"]).as_posix(), row["sha256"]) rgb = frame.to_ndarray(format="rgb24") require(rgb.shape == (expected.height, expected.width, 3), "video dimensions differ from PNG") dimensions = [expected.width, expected.height] flat_frames += int(rgb.max() == rgb.min()) differences.append(float(np.abs(rgb.astype(np.int16) - np.asarray(expected).astype(np.int16)).mean())) count += 1 require(count == len(rows), "video frame count differs from native frames") require(stream_hash(files.path(relative)) == digest, "video changed during audit") return {"path": relative, "sha256": digest, "frames": count, **({"presentation_timestamps_verified_hz": expected_hz} if expected_hz is not None else {}), "dimensions": dimensions, "flat_frames": flat_frames, "maximum_png_pixel_mae_255": max(differences, default=None), "mean_png_pixel_mae_255": sum(differences) / count if count else None, "comparison": "Lossy-codec differences are reported, not a task score or automatic parity verdict."} def audit_robocasa_controls(files: ClosedFiles, result: dict, events: list) -> int: """Compare retained adapter-side native call records; do not invoke a scorer.""" rows = files.jsonl(bound_reference(files, result["artifacts"]["native_actions"])) controls = [event for event in events if event["event"] == "environment_step"] require(len(rows) == 2 * len(controls) == 2 * result["environment_steps"], "RoboCasa native action coverage mismatch") for index, event in enumerate(controls, 1): start, end = rows[2 * index - 2:2 * index] for vector in (start.get("action"), event.get("action")): require(isinstance(vector, list) and bool(vector) and all(type(value) in (int, float) and math.isfinite(value) for value in vector), "RoboCasa native/runner action must contain finite nonboolean numbers") require(set(start) == {"event", "step", "action"} and start["event"] == "native_action_start" and type(start["step"]) is int and start["step"] == index and start["action"] == event["action"], "RoboCasa native action start mismatch") require(set(end) == {"event", "step", "reward", "native_success", "native_done", "native_truncated", "adapter_truncated"} and end["event"] == "native_action_end" and type(end["step"]) is int and end["step"] == index, "RoboCasa native action end identity mismatch") require(all(type(end[key]) is bool for key in ("native_success", "native_done", "native_truncated", "adapter_truncated")), "RoboCasa native flag type mismatch") require(type(end["reward"]) in (int, float) and end["reward"] == float(end["native_success"]) and end["reward"] == event["reward"] and type(event["reward"]) in (int, float) and end["native_success"] is event["info"]["native_success"] and type(event["info"]["native_steps"]) is int and event["info"]["native_steps"] == index and event["terminated"] is (end["native_done"] or end["native_success"]) and event["truncated"] is end["adapter_truncated"], "RoboCasa native/runner transition mismatch") require(not end["native_truncated"] or end["adapter_truncated"], "RoboCasa native truncation lost") require(result["success"] is (rows[-1]["native_success"] if rows else False), "RoboCasa final native score mismatch") return len(controls) def finite_vector(value, size: int) -> bool: return (isinstance(value, list) and len(value) == size and all(type(item) in (int, float) and math.isfinite(item) for item in value)) def simple_layout(files: ClosedFiles, manifest: dict, result: dict, base: Path | None): """Read only retained episode files; no native imports or external fingerprints.""" require(base is not None, "SIMPLE requires the audited result directory, not a reconstructed episode ID") native = files.json((base / result["artifacts"]["native_provenance"]).as_posix()) spec = manifest["observation_spec"] names = spec["state_names"] require(spec["cameras"] == ["head_stereo_left"] and len(names) == 31 and all(isinstance(name, str) and name for name in names) and len(set(names)) == 31 and names == manifest["action_spec"]["names"][:31] and names == native["public_state_names"], "unsupported SIMPLE camera/state track") require(native["diagnostic_only"] is False and result["metrics"]["diagnostic_only"] is False, "SIMPLE diagnostic is not a capability attempt") raw = native["instruction"] require(isinstance(raw, str) and bool(raw.strip()) and raw.strip() == result["episode"]["instruction"], "SIMPLE episode instruction mismatch") require(native["task"] == result["episode"]["task"], "SIMPLE retained task mismatch") if "selected_task_configuration" in native: require(native["selected_task_configuration"]["instruction"] == raw, "SIMPLE retained configuration instruction mismatch") rows = [] for step in range(result["environment_steps"] + 1): relative = f"rgb/head_stereo_left_{step:06d}.png" path = (base / relative).as_posix() files.raw(path) rows.append({"step": step, "camera": "head_stereo_left", "path": relative, "sha256": files.hashes[path], "instruction": raw}) expected = {row["path"] for row in rows} actual = set() for path in (files.root / base / "rgb").rglob("*"): require(not path.is_symlink(), "symlink in SIMPLE PNG directory") if path.is_file(): actual.add(path.relative_to(files.root / base).as_posix()) require(actual == expected, "SIMPLE PNG directory coverage gap/extra") return base, rows, native def audit_simple_controls(files: ClosedFiles, base: Path, native: dict, spec: dict, result: dict, events: list, observations: dict) -> int: names = spec["state_names"] for observation in observations.values(): require(finite_vector(observation["state"], 31), "SIMPLE state must be 31 finite nonboolean numbers") require(observation["instruction"] == native["instruction"], "SIMPLE raw native language mismatch") controls = [event for event in events if event["event"] == "environment_step"] relative = (base / "private_native_ticks.jsonl").as_posix() require(not (files.root / relative).is_symlink(), "symlink in SIMPLE optional tick path") rows = files.jsonl(relative) if controls or (files.root / relative).exists() else [] require(len(rows) == len(controls) == result["environment_steps"], "SIMPLE native tick coverage mismatch") total = 0.0 for index, (row, event) in enumerate(zip(rows, controls), 1): require(set(row) == {"joint_positions", "reward", "success", "terminated", "truncated", "native_steps", "step_wall_seconds"}, "SIMPLE native tick fields mismatch") require(type(row["native_steps"]) is int and row["native_steps"] == index and type(event["info"]["native_steps"]) is int and event["info"]["native_steps"] == index, "SIMPLE native tick counter mismatch") require(all(type(row[key]) is bool for key in ("success", "terminated", "truncated")) and row["success"] is event["info"]["native_success"] and row["terminated"] is event["terminated"] and row["truncated"] is event["truncated"], "SIMPLE native tick flag mismatch") require(type(row["reward"]) in (int, float) and math.isfinite(row["reward"]) and type(event["reward"]) in (int, float) and row["reward"] == event["reward"] and type(row["step_wall_seconds"]) in (int, float) and math.isfinite(row["step_wall_seconds"]) and row["step_wall_seconds"] >= 0, "SIMPLE native tick reward/time mismatch") joints = row["joint_positions"] require(isinstance(joints, dict) and set(joints) == set(names), "SIMPLE private encoder names mismatch") values = [joints[name] for name in names] require(finite_vector(values, 31) and values == observations[index]["state"], "SIMPLE private/public encoder mismatch") total += row["reward"] require(result["success"] is (rows[-1]["success"] if rows else False), "SIMPLE final native score mismatch") require(type(result["metrics"]["native_steps"]) is int and result["metrics"]["native_steps"] == len(rows) and type(result["metrics"]["native_return"]) in (int, float) and result["metrics"]["native_return"] == total, "SIMPLE native metric mismatch") return len(rows) def audit_private_simple_video(files: ClosedFiles, relative: str, count: int) -> dict: """These cameras have no retained PNGs. Decode/timing is not pixel parity.""" import av digest = stream_hash(files.path(relative)) frames = flat = 0 dimensions = None with av.open(str(files.path(relative))) as container: require(len(container.streams.video) == 1, "video must have one video stream") for frame in container.decode(video=0): require(frames < count, "SIMPLE private video has extra frames") require(frame.pts is not None and frame.time_base is not None and frame.pts * frame.time_base == Fraction(frames, 50), "SIMPLE private video presentation timestamp mismatch") rgb = frame.to_ndarray(format="rgb24") size = [frame.width, frame.height] require(frame.width > 0 and frame.height > 0 and (dimensions is None or dimensions == size), "SIMPLE private video dimension drift") dimensions = size flat += int(rgb.max() == rgb.min()) frames += 1 require(frames == count, "SIMPLE private video frame count mismatch") require(stream_hash(files.path(relative)) == digest, "SIMPLE private video changed during audit") return {"path": relative, "sha256": digest, "frames": frames, "dimensions": dimensions, "presentation_timestamps_verified_hz": 50, "flat_frames": flat, "maximum_png_pixel_mae_255": None, "mean_png_pixel_mae_255": None, "comparison": "No retained source PNGs: decode/hash/timestamps only; pixel parity unavailable."} def audit_simple_videos(files: ClosedFiles, base: Path, result: dict, rows: list) -> list: import av inventory = files.json((base / result["artifacts"]["video_manifest"]).as_posix()) indexed = {} for row in inventory: relative = bound_reference(files, row["path"]) path = Path(relative) camera = path.stem require(path.parent == base and path.suffix == ".mp4" and camera not in indexed, "SIMPLE video identity/path mismatch") require(type(row["frames"]) is int and row["frames"] == len(rows) and type(row["fps"]) in (int, float) and row["fps"] == 50 and type(row["size"]) is int and row["size"] == files.path(relative).stat().st_size and row["sha256"] == stream_hash(files.path(relative)), "SIMPLE video manifest mismatch") require(result["artifacts"].get(f"video_{camera}") == path.name, "SIMPLE result video reference mismatch") with av.open(str(files.path(relative))) as container: require(len(container.streams.video) == 1 and container.streams.video[0].average_rate == 50, "SIMPLE video stream rate differs from 50 Hz") indexed[camera] = (relative, row["sha256"]) require(set(indexed) in (SIMPLE_HEAD_CAMERAS, SIMPLE_ALL_CAMERAS), "unsupported SIMPLE private camera set") require({key for key in result["artifacts"] if key.startswith("video_") and key != "video_manifest"} == {f"video_{camera}" for camera in indexed}, "SIMPLE result video coverage mismatch") videos = [] for camera, (relative, digest) in sorted(indexed.items()): checked = (audit_video(files, relative, rows, base, expected_hz=50) if camera == "head_stereo_left" else audit_private_simple_video(files, relative, len(rows))) require(checked["sha256"] == digest, "SIMPLE video changed after manifest check") videos.append({"camera": camera, **checked}) return videos def audit_payload(files: ClosedFiles, mailbox: ClosedFiles, manifest: dict, result: dict, events: list, *, episode_artifact_base: Path | None = None) -> dict: require(result["status"] == "completed", "full artifact audit requires a completed episode; retain errors separately") benchmark = manifest["benchmark"]["name"] require(benchmark in {"libero", "simpler_env", "robocasa365", "simple_humanoid"}, "unsupported native frame layout") version = manifest["policy"]["version"] require(version in {"starvla-rsi.mailbox/v2", "starvla-rsi.mailbox/v3"}, "unsupported mailbox schema") parameters = manifest["policy"]["parameters"] require(Path(parameters["directory"]) == mailbox.root, "caller mailbox differs from recorded endpoint") ready = mailbox.json("ready.json") require(ready["status"] == "episode_closed", "mailbox is not closed") require(ready["schema_version"] == manifest["policy"]["version"], "ready schema mismatch") spec, action, protocol = (manifest[name] for name in ("observation_spec", "action_spec", "protocol")) require(spec["privileged"] is False, "privileged observation track") cameras = spec["cameras"] require(cameras and len(set(cameras)) == len(cameras), "invalid camera set") if benchmark == "robocasa365": require(cameras == ROBOCASA_CAMERAS and spec["state_names"] == [], "unsupported RoboCasa public camera/state track") if benchmark == "simple_humanoid": frame_base, rows, simple_native = simple_layout(files, manifest, result, episode_artifact_base) else: frame_index = bound_reference(files, result["artifacts"]["frames"]) frame_base = Path(frame_index).parent rows = files.jsonl(frame_index) steps = result["environment_steps"] expected_keys = {(step, camera) for step in range(steps + 1) for camera in cameras} indexed = {} image_paths = set() for row in rows: key = (row["step"], row["camera"]) require(type(row["step"]) is int and key not in indexed, "duplicate/invalid native frame identity") relative = (frame_base / row["path"]).as_posix() require(not Path(row["path"]).is_absolute() and relative not in image_paths, "duplicate/absolute native frame path") decoded = png(files, relative, row["sha256"]) if benchmark == "robocasa365": require(decoded.size == (256, 256), "RoboCasa native PNG dimensions changed") if benchmark == "simple_humanoid": require(decoded.size == (640, 360), "SIMPLE native PNG dimensions changed") image_paths.add(relative) indexed[key] = row require(set(indexed) == expected_keys, "native frame coverage gap/extra") observations = {} current_step = 0 scheduled = {} scheduled_feedback = {} executed_by_call = {} active_call = 0 decisions = [] for event in events: if event["event"] in {"observation", "environment_step"}: observation = event["observation"] if benchmark == "simple_humanoid": expected_step = len(observations) require(type(observation["step"]) is int and observation["step"] == expected_step and event["event"] == ("observation" if expected_step == 0 else "environment_step"), "SIMPLE observation step must match chronological native control identity") current_step = observation["step"] require(current_step not in observations, "duplicate native observation") observations[current_step] = observation if event["event"] == "environment_step": executed_by_call[active_call] = executed_by_call.get(active_call, 0) + 1 elif event["event"] == "policy_call_start": scheduled[event["policy_call"]] = current_step scheduled_feedback[event["policy_call"]] = { "policy_calls": active_call, "action_decisions": len(executed_by_call), "environment_steps": sum(executed_by_call.values()), "executed_steps": executed_by_call.get(active_call, 0), } active_call = event["policy_call"] elif event["event"] == "policy_decision": decisions.append(event) require(set(observations) == set(range(steps + 1)), "native observation coverage gap") require(len(decisions) == result["policy_calls"], "missing returned decisions") require(all(set(row["camera_names"]) == set(cameras) and row["metadata"] == {} for row in observations.values()), "native exported observation boundary mismatch") simple_controls = (audit_simple_controls(files, frame_base, simple_native, spec, result, events, observations) if benchmark == "simple_humanoid" else None) expected_budgets = { "budget_mode": protocol["budget_mode"], "primary_budget": protocol["primary_budget"], "max_steps": protocol["max_steps"], "max_policy_calls": protocol["max_policy_calls"], "replan_interval": protocol["replan_interval"], "max_chunk_length": parameters["max_chunk_length"], "response_timeout_s": parameters["timeout_s"], "max_provider_calls_per_decision": 1, "provider_call_limit_verified": False, } request_ids = set() public_image_count = 0 for decision in decisions: metadata = decision["metadata"] request_id = metadata["request_id"] require(request_id not in request_ids, "duplicate request ID") request_ids.add(request_id) observation_path = bound_reference(mailbox, metadata["observation_path"]) response_path = bound_reference(mailbox, metadata["response_path"]) turn = Path(observation_path).parent require(turn == Path(response_path).parent and turn.name == request_id, "request/response directory mismatch") public = mailbox.json(observation_path) feedback = scheduled_feedback[decision["policy_call"]] audit_policy_fields(public, version, parameters, protocol, feedback) if benchmark == "simple_humanoid": require(finite_vector(public["state"], 31), "SIMPLE public state must be 31 finite nonboolean numbers") require(type(public["step"]) is int, "SIMPLE public step must be a nonboolean integer") require(public["schema_version"] == manifest["policy"]["version"] and public["request_id"] == request_id, "public request/schema mismatch") step = scheduled[decision["policy_call"]] native = observations[step] require(public["step"] == step and public["instruction"] == native["instruction"] and public["state"] == native["state"], "public observation differs from scheduled native input") require(public["state"] is None if not spec["state_names"] else isinstance(public["state"], list) and len(public["state"]) == len(spec["state_names"]), "undeclared public proprioception") require(public["observation_spec"] == spec and public["action_spec"] == action, "public specification drift") turn_budgets = dict(expected_budgets) if version.endswith("/v2") and protocol.get("min_action_decisions_before_give_up", 0): minimum = protocol["min_action_decisions_before_give_up"] turn_budgets.update({key: protocol[key] for key in ( "stop_constraint_version", "min_action_decisions_before_give_up", "early_policy_stop_exception")}) turn_budgets.update(completed_action_decisions=feedback["action_decisions"], voluntary_stop_allowed=feedback["action_decisions"] >= minimum) require(public["budgets"] == turn_budgets and public["history"] == parameters["history"], "public budget/history drift") require(hashlib.sha256(public["prompt"].encode()).hexdigest() == parameters["prompt_sha256"], "public prompt drift") require(mailbox.json(response_path) == metadata["structured_response"], "accepted response differs from event") require(set(public["images"]) == set(cameras), "public camera set drift") for camera, image in public["images"].items(): require(set(image) == IMAGE_FIELDS and image["encoding"] == "png" and image["color_space"] == "RGB", "public image schema drift") require(Path(image["path"]).parent == turn, "public image outside current request") actual = png(mailbox, image["path"], image["sha256"]) row = indexed[(step, camera)] expected = png(files, (frame_base / row["path"]).as_posix(), row["sha256"]) require(actual.size == expected.size == (image["width"], image["height"]) and actual.tobytes() == expected.tobytes(), "public/native pixel mismatch") if "instruction" in row: require(row["instruction"] == public["instruction"], "frame instruction mismatch") public_image_count += 1 videos = [] for camera in ([] if benchmark == "simple_humanoid" else cameras): key = "video" if benchmark == "simpler_env" else f"{camera}_video" relative = bound_reference(files, result["artifacts"][key]) camera_rows = [indexed[(step, camera)] for step in range(steps + 1)] videos.append({"camera": camera, **audit_video( files, relative, camera_rows, frame_base, expected_hz=20 if benchmark == "robocasa365" else None)}) native_controls = ({"native_control_pairs_verified": audit_robocasa_controls(files, result, events)} if benchmark == "robocasa365" else {}) if benchmark == "simple_humanoid": videos = audit_simple_videos(files, frame_base, result, rows) native_controls = {"native_ticks_verified": simple_controls, "native_instruction_binding": "Exact retained provenance/observation/public text and retained configuration when present; EpisodeSpec alone strips outer whitespace.", "retained_configuration_instruction_verified": "selected_task_configuration" in simple_native, "native_png_hash_origin": "Computed from retained files; SIMPLE does not retain a native frame-hash index."} return {"episode_id": result["episode"]["id"], "native_success": result["success"], **native_controls, "controls": steps, "decisions": result["policy_calls"], "native_pngs_verified": len(rows), "public_images_matched": public_image_count, "public_observations_verified": len(decisions), "videos": videos} def audit_artifacts(run: Path, mailbox_dir: Path) -> dict: own_path = Path(__file__).resolve() own_hash = stream_hash(own_path) record_report = audit_run(run) require(len(record_report["episodes"]) == 1, "supply a single-case closed run") files, mailbox = ClosedFiles(run), ClosedFiles(mailbox_dir) manifest = files.json("manifest.json") results = files.jsonl("episodes.jsonl") result_path = next((files.root / "episodes").glob("*/result.json")) result = files.json(result_path.relative_to(files.root).as_posix()) require(results == [result], "episode changed after record audit") event_path = result_path.with_name("events.jsonl").relative_to(files.root).as_posix() row = audit_payload(files, mailbox, manifest, result, files.jsonl(event_path), episode_artifact_base=result_path.parent.relative_to(files.root) / "artifacts") # Recheck the entire previously audited record inventory, not only image inputs. for relative, digest in record_report["read_file_sha256"].items(): require(stream_hash(files.path(relative)) == digest, "record changed during image audit") for video in row["videos"]: require(stream_hash(files.path(video["path"])) == video["sha256"], "video changed before audit completed") files.verify_unchanged() mailbox.verify_unchanged() require(stream_hash(own_path) == own_hash, "artifact auditor changed during audit") return {"schema_version": "starvla-rsi.closed-mailbox-artifacts/v1", "artifact_consistency": "passed", "run_dir": str(files.root), "authorized_mailbox": str(mailbox.root), "artifact_auditor_sha256": own_hash, "record_audit": record_report, "episode": row, "run_files_sha256": files.hashes, "mailbox_files_sha256": mailbox.hashes, "limitations": ["No simulator, scorer, external assets or native policy is executed.", "Only complete single-episode LIBERO/SimplerEnv/RoboCasa365 and SIMPLE RGB+qpos31 mailbox-v2/v3 records are supported; failed records use the separate generic record audit.", "SIMPLE checks retained ticks/language/encoders and 50 Hz videos, not native source/reset/campaign/asset closure or runtime warning impact. Private cameras lack PNG pixel parity; reset has no private tick.", "RoboCasa checks retained native call pairs and 20 Hz video timestamps, not actuator traces or native source/reset/asset provenance.", "Accepted responses are compared with events; original action.json files, the frozen response parser and native action-contract validity are not checked here.", "Errors remain attempts; unsupported/error audits do not authorize retries or exclusion.", "No OS sandbox, actor-access attestation or trusted provider/model/usage accounting.", "Pixel differences for lossy videos require interpretation, not automatic native parity."]} def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--run-dir", required=True, type=Path) parser.add_argument("--mailbox-dir", required=True, type=Path) parser.add_argument("--output", required=True, type=Path) args = parser.parse_args() output = args.output.absolute() for root in (args.run_dir.resolve(strict=True), args.mailbox_dir.resolve(strict=True)): require(not output.resolve().is_relative_to(root), "audit output must be outside both closed inputs") require(not output.exists() and not output.is_symlink(), "audit output already exists") report = audit_artifacts(args.run_dir, args.mailbox_dir) with output.open("x", encoding="utf-8") as handle: json.dump(report, handle, ensure_ascii=False, sort_keys=True, indent=2, allow_nan=False) handle.write("\n") print(output) if __name__ == "__main__": main()