"""Export a closed run's results without requiring interaction logs or source audits. Any trusted driver may emit the documented JSON record contract. Python Policy, model transcripts, event streams and source snapshots are not admission gates. Validation here establishes record consistency, not native/provider attestation. """ from __future__ import annotations import argparse import hashlib import html import json import math import os from pathlib import Path import re import tempfile from benchkit.audits.closed_run import ClosedFiles, counter, require from benchkit.methods import (USAGE_FIELDS, method_from_policy, normalize_method, normalize_usage, normalize_component_usage, sum_component_usage) SCHEMA = "starvla-rsi.basic-result/v1" MAX_BYTES = 128 * 1024 * 1024 MAX_EPISODES = 10000 class _Files(ClosedFiles): def __init__(self, root): require(not Path(root).is_symlink(), "run root must not be a symlink") super().__init__(Path(root)) self.sizes = {} self.total = 0 def raw(self, relative): size = self.path(relative).stat().st_size require(self.total + size <= MAX_BYTES, "result input exceeds total byte limit") data = super().raw(relative) self.total += len(data) self.sizes[relative] = len(data) require(self.total <= MAX_BYTES, "result input exceeds total byte limit") return data def verify_unchanged(self): for relative, expected in self.hashes.items(): path = self.path(relative) remaining = self.sizes[relative] require(path.stat().st_size == remaining, "record changed during export") digest = hashlib.sha256() with path.open("rb") as stream: while remaining: block = stream.read(min(65536, remaining)) require(bool(block), "record changed during export") remaining -= len(block) digest.update(block) require(not stream.read(1), "record changed during export") require(digest.hexdigest() == expected, "record changed during export") def _object(value, label): require(type(value) is dict, label + " must be an object") return value def _text(value, label, *, optional=False): if optional and value is None: return None require(isinstance(value, str) and 0 < len(value) <= 4096 and not any(ord(c) < 32 or 0xD800 <= ord(c) <= 0xDFFF for c in value), "invalid " + label) require(not value.startswith(("/", "~/", "\\\\")) and re.match(r"^[A-Za-z]:[\\/]", value) is None, "private path in " + label) return value def _same(left, right): if type(left) is bool or type(right) is bool: return type(left) is type(right) and left == right if type(left) is dict and type(right) is dict: return set(left) == set(right) and all(_same(left[k], right[k]) for k in left) if type(left) in (float, int) and type(right) in (float, int): return math.isclose(left, right, rel_tol=1e-9, abs_tol=1e-9) return left == right def _sum_usage(rows): out = dict.fromkeys(USAGE_FIELDS, 0) for row in rows: usage = normalize_usage(row.get("usage")) out = {key: None if out[key] is None or usage[key] is None else out[key] + usage[key] for key in USAGE_FIELDS} return out def _metric_keys(values): require(isinstance(values, (tuple, list)) and len(values) <= 64, "invalid metric selection") require(all(isinstance(key, str) and re.fullmatch(r"[A-Za-z][A-Za-z0-9_.-]{0,127}", key) for key in values), "invalid metric key") require(len(values) == len(set(values)), "duplicate metric selection") return list(values) def _public_contracts(manifest): result = {} for name, labels, lists in (("action_spec", ("mode", "frame", "rotation", "gripper"), ("names",)), ("observation_spec", ("control_feedback_schema",), ("cameras", "state_names", "modalities"))): value = _object(manifest.get(name), name) row = {key: _text(value.get(key), key, optional=True) for key in labels} for key in lists: items = value.get(key, []) require(type(items) is list and len(items) <= 4096, "invalid contract list") row[key] = [_text(item, key) for item in items] if name == "action_spec": row["size"] = counter(value.get("size"), "action size") require(0 < row["size"] <= 4096, "invalid action size") require(not row["names"] or len(row["names"]) == row["size"], "action names/dimension mismatch") hz = value.get("control_hz") require(hz is None or type(hz) in (int, float) and math.isfinite(hz) and hz > 0, "invalid control frequency") row["control_hz"] = hz for key in ("low", "high"): bound = value.get(key) require(bound is None or type(bound) is list and len(bound) == row["size"] and all(type(v) in (int, float) and math.isfinite(v) for v in bound), "invalid action bounds") row[key] = bound require((row["low"] is None) == (row["high"] is None), "unpaired action bounds") if row["low"] is not None: require(all(a <= b for a, b in zip(row["low"], row["high"])), "inverted action bounds") else: require(value.get("privileged") is False, "undeclared/private observation contract") row["privileged"] = False result[name] = row return result def _recording(manifest): declaration = manifest.get("recording") if declaration is None: return {"availability": "not_declared", "configuration": None, "publication_requirement": False} value = _object(declaration, "recording") # Only known scalar settings, never paths, arbitrary metadata or receipts. allowed = {"mode", "preset", "schema_version", "scope", "source_capture"} settings = {key: _text(value[key], "recording " + key) for key in allowed if key in value} boolean_options = {"interactions", "model_io", "tool_traces", "images", "videos"} for key in boolean_options: if key in value: require(type(value[key]) is bool, "invalid recording option") settings[key] = value[key] if "agent_events_written" in value: settings["agent_events_written"] = counter(value["agent_events_written"], "agent event count") if "warnings" in value: warnings = value["warnings"] require(type(warnings) is list and len(warnings) <= 16 and all(isinstance(item, str) and re.fullmatch(r"[a-z_]{1,128}", item) for item in warnings), "invalid recording warnings") settings["warnings"] = list(warnings) return {"availability": "declared_settings_only", "configuration": settings, "publication_requirement": False} def _build_result(run_dir, metrics=()): metric_keys = _metric_keys(metrics) files = _Files(run_dir) status = _object(files.json("status.json"), "status") require(status.get("status") in {"completed", "completed_with_errors"}, "run is not closed") manifest = _object(files.json("manifest.json"), "manifest") require(manifest.get("schema_version") == "starvla-rsi.eval/v1", "unsupported run schema") protocol = _object(manifest.get("protocol"), "protocol") benchmark = _object(manifest.get("benchmark"), "benchmark") policy = _object(manifest.get("policy"), "policy") _text(policy.get("name"), "policy name") method = normalize_method(manifest["method"]) if "method" in manifest else method_from_policy(policy) public_benchmark = {key: _text(benchmark.get(key), key) for key in ( "name", "version", "protocol_version", "source_revision")} contracts = _public_contracts(manifest) schedule = protocol.get("episode_ids") require(type(schedule) is list and 0 < len(schedule) <= MAX_EPISODES, "invalid episode schedule") for identifier in schedule: _text(identifier, "episode ID") require(len(schedule) == len(set(schedule)), "duplicate scheduled episode") rows = files.jsonl("episodes.jsonl") require(0 < len(rows) <= len(schedule) and len(rows) == counter(status.get("episodes_written"), "written episodes"), "closed episode count mismatch") episode_root = files.root / "episodes" require(episode_root.is_dir() and not episode_root.is_symlink(), "invalid episodes directory") paths = list(episode_root.glob("*/result.json")) require(len(paths) == len(rows), "episode directory/index count mismatch") indexed = {} for path in paths: row = _object(files.json(path.relative_to(files.root).as_posix()), "episode result") episode = _object(row.get("episode"), "episode") identifier = _text(episode.get("id"), "episode ID") require(identifier not in indexed, "duplicate episode result identity") indexed[identifier] = row public_rows = [] component_usage = {row["id"]: dict.fromkeys(USAGE_FIELDS, 0) for row in method["models"]} max_steps = counter(protocol.get("max_steps"), "control budget") require(max_steps > 0, "control budget must be positive") max_calls = protocol.get("max_policy_calls") if max_calls is not None: require(counter(max_calls, "decision budget") > 0, "decision budget must be positive") for position, row in enumerate(rows): row = _object(row, "indexed result") require(row.get("schema_version") == "starvla-rsi.eval/v1", "unsupported episode result") episode = _object(row.get("episode"), "episode identity") identifier = _text(episode.get("id"), "episode ID") require(identifier == schedule[position] and indexed.get(identifier) == row, "episode index/schedule/result mismatch") seed = episode.get("seed") require(type(seed) is int, "invalid episode seed") counts = {key: counter(row.get(key, 0) if key == "rejected_actions" else row.get(key), key) for key in ("policy_calls", "action_decisions", "environment_steps", "rejected_actions")} require(counts["action_decisions"] <= counts["policy_calls"] and counts["action_decisions"] <= counts["environment_steps"] and counts["rejected_actions"] <= counts["policy_calls"], "inconsistent episode counters") require(counts["environment_steps"] <= max_steps and (max_calls is None or counts["policy_calls"] <= max_calls), "declared budget exceeded") require(row.get("status") in {"completed", "error"}, "invalid episode status") completed = row["status"] == "completed" success = row.get("success") require(type(success) is bool if completed else success is None, "invalid success value") require(completed or success is None, "errored episode cannot declare success") private_metrics = _object(row.get("metrics"), "metrics") if completed: require(type(private_metrics.get("success")) is bool and success == private_metrics["success"], "native/result success mismatch") error = row.get("error") require((error is None) == completed, "episode error/status mismatch") public_error = None if error is not None: _object(error, "error") require(error.get("category") in {"policy", "protocol", "infrastructure", "evaluation"}, "invalid error category") public_error = {"category": error["category"], "type": _text(error.get("type"), "error type")} selected_metrics = {} for key in metric_keys: number = private_metrics.get(key) require(number is None or type(number) in (bool, int, float) and math.isfinite(number), "selected native metric must be a finite numeric/boolean scalar or null") selected_metrics[key] = number duration = row.get("duration_s") require(type(duration) in (int, float) and math.isfinite(duration) and duration >= 0, "invalid episode duration") component = normalize_component_usage(row.get("component_usage"), method) component_usage = sum_component_usage(component_usage, component, method) public_rows.append({"id": identifier, "task": _text(episode.get("task"), "task"), "seed": seed, "status": row["status"], "success": success, "termination_reason": _text(row.get("termination_reason"), "termination reason"), "counters": counts, "duration_s": duration, "usage": normalize_usage(row.get("usage")), "component_usage": component, "native_metrics": selected_metrics, "error": public_error, "recording": _recording(row)}) completed = sum(row["status"] == "completed" for row in rows) successes = sum(row["status"] == "completed" and row["success"] is True for row in rows) require(type(protocol.get("fail_fast")) is bool, "invalid fail-fast setting") require(len(rows) == len(schedule) or protocol["fail_fast"] and rows[-1]["status"] == "error", "unexplained omitted scheduled episodes") require(status["status"] == ("completed" if completed == len(rows) else "completed_with_errors"), "run/episode status mismatch") summary = _object(files.json("summary.json"), "summary") require(summary.get("run_id") == manifest.get("run_id") and summary.get("benchmark") == benchmark["name"] and summary.get("policy") == policy.get("name"), "summary identity mismatch") expected = {"attempted": len(rows), "completed": completed, "errors": len(rows) - completed, "successes": successes, "policy_calls": sum(row["policy_calls"] for row in rows), "rejected_actions": sum(row.get("rejected_actions", 0) for row in rows)} for key, number in expected.items(): require(counter(summary.get(key, 0) if key == "rejected_actions" else summary.get(key), key) == number, "summary counter mismatch: " + key) usage = _sum_usage(rows) require(_same(normalize_usage(summary.get("usage")), usage), "summary usage mismatch") if "component_usage" in summary: require(_same(normalize_component_usage(summary["component_usage"], method), component_usage), "summary component usage mismatch") outcome = {"scope": "client_selected_schedule", "planned": len(schedule), "unattempted": len(schedule) - len(rows), **expected, "action_decisions": sum(row["action_decisions"] for row in rows), "environment_steps": sum(row["environment_steps"] for row in rows), "success_rate": successes / completed if completed else None, "attempt_success_rate": successes / len(rows), "selected_success_rate": successes / len(schedule), "rate_denominators": {"success_rate": "completed_cases", "attempt_success_rate": "attempted_cases", "selected_success_rate": "selected_cases", "completion_rate": "attempted_cases"}, "completion_rate": completed / len(rows)} for key in ("success_rate", "attempt_success_rate", "selected_success_rate", "completion_rate"): if key in summary: require(_same(summary[key], outcome[key]), "summary rate mismatch: " + key) public_protocol = {key: _text(protocol.get(key), key, optional=True) for key in ("budget_mode", "primary_budget", "invalid_action_handling", "usage_accounting_version")} prefix = protocol.get("replan_interval") if prefix is not None: require(counter(prefix, "action prefix") > 0, "invalid action prefix") public_protocol.update(max_steps=max_steps, max_policy_calls=max_calls, replan_interval=prefix) method_origin = manifest.get("method_origin", "participant_declaration" if "method" in manifest else "legacy_policy_projection") require(method_origin in {"participant_declaration", "legacy_policy_projection"}, "invalid method origin") report = {"schema_version": SCHEMA, "run_id": _text(manifest.get("run_id"), "run ID"), "benchmark": public_benchmark, "method": method, "method_origin": method_origin, "configuration_availability": "participant_supplied" if method_origin == "participant_declaration" else "not_supplied_in_legacy_identity_projection", "identity_evidence": "participant_declaration_not_provider_attestation", "protocol": public_protocol, "contracts": contracts, "recording": _recording(manifest), "outcome": outcome, "usage": usage, "component_usage": component_usage, "episodes": public_rows, "selected_native_metrics": metric_keys, "record_check": "closed_result_index_and_summary_consistent", "limitations": ["Interaction recording is optional and is not a publication requirement.", "No event, source, provider or native execution audit is implied by this presentation.", "The denominator is the client-selected schedule, not necessarily the entire benchmark.", "Missing usage is unknown, not zero; model composition and usage are reported declarations.", "Native metrics are included only when explicitly selected; no media or raw traces are copied.", "Review public method configuration and text before publishing; key filtering is not secret detection."]} files.verify_unchanged() return report, files def build_result(run_dir: Path, *, metrics=()): """Read closed results only; interaction/source evidence is never required.""" return _build_result(run_dir, metrics)[0] def render_html(report): esc = lambda value: html.escape(str(value), quote=True) record = lambda value: "
" + esc(json.dumps(value, indent=2, ensure_ascii=False)) + "
" parts = ['', '', 'Agent method evaluation result', '

' + esc(report["method"]["id"]) + ' — ' + esc(report["benchmark"]["name"]) + '

', '

Run ' + esc(report["run_id"]) + '. Method results, not a bare-model ranking.

', '

Outcome

', '

' + esc(report["outcome"]["successes"]) + ' / ' + esc(report["outcome"]["planned"]) + ' successes / selected cases (' + esc(format(report["outcome"]["selected_success_rate"], ".1%")) + '). ' + esc(report["outcome"]["errors"]) + ' errors; ' + esc(report["outcome"]["unattempted"]) + ' unattempted. ' + 'This denominator is the selected schedule, not necessarily the full benchmark.

', record(report["outcome"]), '

Method and resources

', '

Configuration: ' + esc(report["configuration_availability"]) + '.

', record(report["method"]), record({"aggregate_usage": report["usage"], "component_usage": report["component_usage"]}), '

Interaction recording

Optional; recording availability does not affect publication eligibility.

', record(report["recording"]), '

Episodes

'] for episode in report["episodes"]: parts += ['
' + esc(episode["task"]) + ' · ' + esc(episode["id"]) + ' · ' + esc(episode["status"]) + '', record(episode), '
'] parts += ['
Benchmark, protocol and robot capabilities', record({key: report[key] for key in ("benchmark", "protocol", "contracts")}), '
', '

Interpretation

']) def export_result(run_dir: Path, output_dir: Path, *, metrics=()): source = Path(run_dir).resolve(strict=True) output = Path(output_dir).absolute() require(not any(parent.is_symlink() for parent in (output, *output.parents)), "symlink in output path") require(not output.resolve().is_relative_to(source), "output must be outside source run") require(not output.exists(), "output directory must be new") report, files = _build_result(run_dir, metrics) encoded = json.dumps(report, indent=2, ensure_ascii=False, allow_nan=False) + "\n" page = render_html(report) files.verify_unchanged() output.parent.mkdir(parents=True, exist_ok=True) with tempfile.TemporaryDirectory(prefix=".rsi-result-", dir=output.parent) as temporary: staged = Path(temporary) / "view" staged.mkdir() for name, payload in (("result.json", encoded), ("index.html", page)): with (staged / name).open("x", encoding="utf-8") as stream: stream.write(payload) files.verify_unchanged() output.mkdir(exist_ok=False) try: os.replace(staged, output) except OSError: output.rmdir() raise return report def main(argv=None): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--run-dir", type=Path, required=True, help="explicit closed client-run directory") parser.add_argument("--output-dir", type=Path, required=True, help="new presentation outside the original run") parser.add_argument("--metric", action="append", default=[], help="explicit native numeric metric key; repeatable") args = parser.parse_args(argv) try: report = export_result(args.run_dir, args.output_dir, metrics=args.metric) except (ValueError, OSError, KeyError, TypeError, OverflowError, RecursionError): parser.exit(2, "Result export rejected: invalid, unsafe, changed or inconsistent closed records.\n") print(json.dumps({"run_id": report["run_id"], "episodes": len(report["episodes"]), "files": ["result.json", "index.html"]})) return 0 if __name__ == "__main__": raise SystemExit(main())