#!/usr/bin/env python3 """Materialize and control-check a frozen private CTX holdout.""" from __future__ import annotations import argparse from collections.abc import Mapping from dataclasses import dataclass import hashlib import json import os from pathlib import Path import secrets import shutil import signal import stat import subprocess import sys import tempfile import time from typing import Any ROOT = Path(__file__).resolve().parents[1] if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) from scripts import ctx_ab_benchmark as benchmark # noqa: E402 from scripts import ctx_ab_exposure_ledger as exposure_ledger # noqa: E402 from scripts import ctx_ab_failure_evidence as failure_evidence # noqa: E402 from scripts import ctx_ab_holdout as holdout # noqa: E402 from scripts import ctx_ab_holdout_freeze as freezer # noqa: E402 from scripts import ctx_ab_swebench as swebench # noqa: E402 OUTPUT_FILES = { "scenario_pack": "scenario-pack.json", "collision": "collision-attestation.json", "reconstructed": "reconstructed-test-attestation.json", "controls": "control-results.json", } VERIFICATION_DIR = "official-verification" VERIFIER_PROTOCOL_KEY = "official_swebench_verifier" PROTOCOL_ID = freezer.PROTOCOL_ID SCENARIO_COUNT = 10 class MaterializationError(RuntimeError): """A private holdout failed deterministic materialization.""" @dataclass(frozen=True) class ProcessResult: returncode: int stdout: str stderr: str timed_out: bool @dataclass(frozen=True) class VerifierRuntime: """Operator-local paths for a protocol-pinned official verifier.""" swebench_checkout: Path swebench_python: Path docker_cli: Path docker_host: str def _canonical_bytes(value: Any) -> bytes: return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode() def _sha256(data: bytes) -> str: return hashlib.sha256(data).hexdigest() def _load_json(path: Path) -> dict[str, Any]: value = json.loads(path.read_text(encoding="utf-8")) if not isinstance(value, dict): raise MaterializationError("JSON input must contain an object") return value def _load_authenticated_protocol(path: Path, *, expected_sha256: str) -> dict[str, Any]: if not isinstance(expected_sha256, str) or freezer.SHA256.fullmatch(expected_sha256) is None: raise MaterializationError("acquisition protocol authentication failed") protocol_bytes = path.read_bytes() if not secrets.compare_digest(_sha256(protocol_bytes), expected_sha256): raise MaterializationError("acquisition protocol authentication failed") value = json.loads(protocol_bytes) if not isinstance(value, dict): raise MaterializationError("acquisition protocol must contain an object") return value def _load_jsonl(path: Path) -> list[dict[str, Any]]: rows = [ json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip() ] if not rows or not all(isinstance(row, dict) for row in rows): raise MaterializationError("canonical JSONL must contain object rows") return rows def _string_list(value: object, *, field: str) -> list[str]: try: items = json.loads(str(value)) except json.JSONDecodeError as exc: raise MaterializationError(f"{field} must be a JSON string list") from exc if ( not isinstance(items, list) or not items or not all(isinstance(item, str) and item for item in items) ): raise MaterializationError(f"{field} must be a non-empty JSON string list") return items def _remaining(deadline: float) -> float: remaining = deadline - time.monotonic() if remaining <= 0: raise MaterializationError("control verification exceeded the frozen timeout") return remaining def _run( argv: list[str], *, cwd: Path, deadline: float, input_text: str | None = None, env: dict[str, str] | None = None, ) -> ProcessResult: process = subprocess.Popen( argv, cwd=cwd, env=env, stdin=subprocess.PIPE if input_text is not None else subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, start_new_session=True, ) try: stdout, stderr = process.communicate(input_text, timeout=_remaining(deadline)) return ProcessResult(process.returncode, stdout, stderr, False) except subprocess.TimeoutExpired: os.killpg(process.pid, signal.SIGKILL) stdout, stderr = process.communicate() return ProcessResult(process.returncode, stdout, stderr, True) def _checked( argv: list[str], *, cwd: Path, deadline: float, input_text: str | None = None, ) -> ProcessResult: result = _run(argv, cwd=cwd, deadline=deadline, input_text=input_text) if result.timed_out: raise MaterializationError("control verification exceeded the frozen timeout") if result.returncode: raise MaterializationError("repository materialization command failed") return result def _validate_runtime(runtime: VerifierRuntime) -> None: for path in ( runtime.swebench_checkout, runtime.swebench_python, runtime.docker_cli, ): if not path.is_absolute(): raise MaterializationError("official verifier runtime paths must be absolute") if not isinstance(runtime.docker_host, str) or not runtime.docker_host: raise MaterializationError("official verifier Docker host is invalid") def _phase_summary( evidence: Mapping[str, Any], *, phase: str, fail_to_pass_count: int, pass_to_pass_count: int, pins: Mapping[str, Any], dataset_sha256: str, ) -> dict[str, Any]: validation = evidence.get("validation") authentication = evidence.get("authentication") python_environment = evidence.get("python_environment") docker_package = evidence.get("docker_package") docker_identity = evidence.get("docker_identity") cleanup = evidence.get("cleanup") process = evidence.get("process") artifacts = evidence.get("artifacts") input_snapshots = evidence.get("input_snapshots") expected_resolution = "RESOLVED_NO" if phase == "red" else "RESOLVED_FULL" expected_resolved = phase != "red" if ( evidence.get("schema_version") != 1 or evidence.get("phase") != phase or not isinstance(validation, Mapping) or validation.get("phase") != phase or validation.get("exact_selector_identity") is not True or validation.get("exact_selector_keys_present") is not True or validation.get("fail_to_pass_count") != fail_to_pass_count or validation.get("pass_to_pass_count") != pass_to_pass_count or validation.get("resolution") != expected_resolution or validation.get("resolved") is not expected_resolved or not isinstance(validation.get("container_policy_count"), int) or isinstance(validation.get("container_policy_count"), bool) or validation["container_policy_count"] < 1 or not swebench.IMAGE_ID_PATTERN.fullmatch(str(validation.get("image_id") or "")) or not isinstance(authentication, Mapping) or authentication.get("git_revision") != pins["revision"] or authentication.get("run_evaluation_sha256") != pins["run_evaluation_sha256"] or not swebench.SHA256_PATTERN.fullmatch(str(authentication.get("source_sha256") or "")) or isinstance(authentication.get("source_file_count"), bool) or not isinstance(authentication.get("source_file_count"), int) or authentication["source_file_count"] < 1 or not isinstance(python_environment, Mapping) or python_environment.get("sha256") != pins["python_environment_sha256"] or isinstance(python_environment.get("distribution_count"), bool) or not isinstance(python_environment.get("distribution_count"), int) or python_environment["distribution_count"] < 1 or not isinstance(docker_package, Mapping) or docker_package.get("sha256") != pins["docker_package_sha256"] or isinstance(docker_package.get("file_count"), bool) or not isinstance(docker_package.get("file_count"), int) or docker_package["file_count"] < 1 or not isinstance(docker_identity, Mapping) or docker_identity.get("server_version") != pins["docker_server_version"] or docker_identity.get("daemon_id_sha256") != _sha256(str(pins["docker_daemon_id"]).encode()) or not isinstance(input_snapshots, Mapping) or input_snapshots.get("bridge_sha256") != pins["bridge_sha256"] or input_snapshots.get("dataset_sha256") != dataset_sha256 or input_snapshots.get("docker_package") != { "file_count": docker_package.get("file_count"), "sha256": pins["docker_package_sha256"], } or input_snapshots.get("harness_source") != { "file_count": authentication.get("source_file_count"), "sha256": authentication.get("source_sha256"), } or not isinstance(cleanup, Mapping) or cleanup.get("ok") is not True or not isinstance(process, Mapping) or process.get("returncode") != 0 or process.get("timed_out") is not False or process.get("residual_descendant_count") != 0 or not isinstance(artifacts, Mapping) ): raise MaterializationError(f"official {phase} control evidence is invalid") expected_artifacts = { *swebench.REQUIRED_ARTIFACTS, "parent-process.json", "verification-evidence.json", "worker-request.json", "worker-result.json", } if phase == "red": expected_artifacts.add("mode-probe.log") if set(artifacts) != expected_artifacts: raise MaterializationError(f"official {phase} artifacts are incomplete") artifact_bytes = 0 for name in sorted(expected_artifacts): item = artifacts.get(name) if ( not isinstance(item, Mapping) or item.get("present") is not True or item.get("name") != name or isinstance(item.get("bytes"), bool) or not isinstance(item.get("bytes"), int) or item["bytes"] < 0 or not swebench.SHA256_PATTERN.fullmatch(str(item.get("sha256") or "")) ): raise MaterializationError(f"official {phase} artifacts are invalid") artifact_bytes += item["bytes"] status_counts = validation.get("status_counts") if ( not isinstance(status_counts, Mapping) or not status_counts or not all( isinstance(status, str) and status in swebench.KNOWN_STATUSES and isinstance(count, int) and not isinstance(count, bool) and count >= 0 for status, count in status_counts.items() ) or sum(status_counts.values()) != fail_to_pass_count + pass_to_pass_count ): raise MaterializationError(f"official {phase} status evidence is invalid") identity = { "authentication": { "git_revision": authentication["git_revision"], "run_evaluation_sha256": authentication["run_evaluation_sha256"], "source_file_count": authentication["source_file_count"], "source_sha256": authentication["source_sha256"], }, "docker_identity": { "daemon_id_sha256": docker_identity["daemon_id_sha256"], "server_version": docker_identity["server_version"], }, "docker_package": { "file_count": docker_package["file_count"], "sha256": docker_package["sha256"], }, "input_snapshots": input_snapshots, "python_environment": { "distribution_count": python_environment.get("distribution_count"), "sha256": python_environment["sha256"], }, } runtime_identity_sha256 = _sha256(_canonical_bytes(identity)) semantic_evidence = { "container_policy_count": validation["container_policy_count"], "exact_selector_identity": True, "fail_to_pass_count": fail_to_pass_count, "image_id": validation["image_id"], "pass_to_pass_count": pass_to_pass_count, "phase": phase, "resolved": expected_resolved, "runtime_identity_sha256": runtime_identity_sha256, "status_counts": dict(sorted(status_counts.items())), } return { "artifact_bytes": artifact_bytes, "artifact_count": len(expected_artifacts), "artifact_manifest_sha256": _sha256(_canonical_bytes(artifacts)), **semantic_evidence, "raw_verifier_evidence_sha256": _sha256(_canonical_bytes(evidence)), "verifier_evidence_sha256": _sha256(_canonical_bytes(semantic_evidence)), } def _control_phase_summary(summary: Mapping[str, Any]) -> dict[str, Any]: fields = ( "artifact_bytes", "artifact_count", "artifact_manifest_sha256", "container_policy_count", "exact_selector_identity", "fail_to_pass_count", "image_id", "pass_to_pass_count", "phase", "runtime_identity_sha256", "status_counts", "verifier_evidence_sha256", ) return {field: summary[field] for field in fields} def _private_write(path: Path, data: bytes) -> None: descriptor = os.open( path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o600, ) with os.fdopen(descriptor, "wb") as handle: handle.write(data) def _retain_phase_artifacts( *, evidence: Mapping[str, Any], instance_id: str, phase: str, source_root: Path, destination_root: Path, summary: Mapping[str, Any], ) -> None: run_id = evidence.get("run_id") model_name = evidence.get("model_name") artifacts = evidence.get("artifacts") if ( not isinstance(run_id, str) or not swebench.RUN_ID_PATTERN.fullmatch(run_id) or not isinstance(model_name, str) or model_name != f"ctx-swebench-{phase}" or not isinstance(artifacts, Mapping) ): raise MaterializationError(f"official {phase} artifact identity is invalid") destination_root.parent.mkdir(mode=0o700, parents=True, exist_ok=True) os.chmod(destination_root.parent, 0o700) destination_root.mkdir(mode=0o700, exist_ok=False) os.chmod(destination_root, 0o700) log_root = source_root / "logs" / "run_evaluation" / run_id / model_name / instance_id root_names = { "mode-probe.log", "parent-process.json", "verification-evidence.json", "worker-request.json", "worker-result.json", } for name, item in sorted(artifacts.items()): if not isinstance(name, str) or not isinstance(item, Mapping): raise MaterializationError(f"official {phase} artifact evidence is invalid") source = source_root / name if name in root_names else log_root / name try: resolved = source.resolve(strict=True) resolved.relative_to(source_root.resolve(strict=True)) except (OSError, ValueError) as exc: raise MaterializationError( f"official {phase} artifact escaped its private root" ) from exc if source.is_symlink() or not source.is_file(): raise MaterializationError(f"official {phase} artifact is not a regular file") data = source.read_bytes() if ( len(data) != item.get("bytes") or _sha256(data) != item.get("sha256") or len(data) > swebench.MAX_EVIDENCE_BYTES ): raise MaterializationError(f"official {phase} artifact changed before retention") _private_write(destination_root / name, data) _private_write(destination_root / "evidence.json", _canonical_bytes(evidence)) _private_write(destination_root / "summary.json", _canonical_bytes(summary)) def _repo_source( row: dict[str, Any], sources: Mapping[str, freezer.SourceBundle], ) -> freezer.SourceBundle: repo = str(row["repo"]).strip().lower() url = holdout.canonical_repo_url(repo) source = sources.get(url) if source is None: raise MaterializationError("selected repository is absent from the source map") if source.base_commit != str(row.get("base_commit") or ""): raise MaterializationError("selected repository source commit is stale") return source def _validate_source_bundle_heads( source: freezer.SourceBundle, *, cwd: Path, deadline: float, ) -> None: listed_heads = _checked( ["git", "bundle", "list-heads", str(source.bundle_path)], cwd=cwd, deadline=deadline, ).stdout.splitlines() if not listed_heads or any( not line.startswith(f"{source.base_commit} ") for line in listed_heads ): raise MaterializationError("repository source bundle exposes an unpinned ref") def _scenario( row: dict[str, Any], *, dataset_path: Path, protocol: dict[str, Any], pins: dict[str, Any], retained_root: Path, runtime: VerifierRuntime, source: freezer.SourceBundle, slot: int, work_root: Path, timeout: float, ) -> tuple[dict[str, Any], benchmark.Scenario, dict[str, Any], str]: started = time.monotonic() deadline = started + timeout workspace = work_root / f"scenario-{slot}" _validate_source_bundle_heads(source, cwd=work_root, deadline=deadline) _checked( [ "git", "-c", "core.hooksPath=/dev/null", "clone", "--quiet", "--no-checkout", "--no-hardlinks", str(source.bundle_path), str(workspace), ], cwd=work_root, deadline=deadline, ) commit = str(row["base_commit"]) _checked( ["git", "-c", "core.hooksPath=/dev/null", "checkout", "--quiet", "--detach", commit], cwd=workspace, deadline=deadline, ) observed = _checked(["git", "rev-parse", "HEAD"], cwd=workspace, deadline=deadline) if observed.stdout.strip() != commit: raise MaterializationError("repository checkout did not reach the pinned commit") future_history = _checked( ["git", "rev-list", "--all", "--not", commit], cwd=workspace, deadline=deadline, ) unreachable = _checked( ["git", "fsck", "--full", "--unreachable", "--no-reflogs"], cwd=workspace, deadline=deadline, ) if future_history.stdout.strip() or unreachable.stdout.strip(): raise MaterializationError("repository source bundle is not a base-commit closure") _checked(["git", "remote", "remove", "origin"], cwd=workspace, deadline=deadline) remotes = _checked(["git", "remote"], cwd=workspace, deadline=deadline) if remotes.stdout.strip(): raise MaterializationError("repository source bundle retained an external remote") tree = _checked( ["git", "rev-parse", "HEAD^{tree}"], cwd=workspace, deadline=deadline, ).stdout.strip() status_result = _checked( ["git", "status", "--porcelain=v1", "--untracked-files=all"], cwd=workspace, deadline=deadline, ) if ( not swebench.REVISION_PATTERN.fullmatch(tree) or tree != source.tree_sha1 or status_result.stdout ): raise MaterializationError("repository checkout is not an exact clean tree") evaluated = holdout.evaluate_row(row, protocol) if evaluated["status"] != "eligible": raise MaterializationError("selected row is no longer statically eligible") test_path = str(evaluated["test_path"]) production_paths = str(evaluated["production_paths"]).split("|") _checked( ["git", "apply", "--whitespace=nowarn", "-"], cwd=workspace, deadline=deadline, input_text=str(row["test_patch"]), ) test_file = workspace / test_path try: resolved_test_file = test_file.resolve(strict=True) resolved_test_file.relative_to(workspace.resolve(strict=True)) except (OSError, ValueError) as exc: raise MaterializationError( "test patch reconstructed a path outside the repository" ) from exc if test_file.is_symlink() or not resolved_test_file.is_file(): raise MaterializationError("test patch did not reconstruct a complete test module") test_source = resolved_test_file.read_text(encoding="utf-8") holdout.validate_reconstructed_test_module(test_source) test_sha256 = _sha256(test_source.encode()) focused = _string_list(row["FAIL_TO_PASS"], field="FAIL_TO_PASS") regressions = _string_list(row["PASS_TO_PASS"], field="PASS_TO_PASS") scenario_id = str(row["instance_id"]) common_verifier = { "allowed_paths": production_paths, "dataset_path": dataset_path, "docker_cli": runtime.docker_cli, "docker_host": runtime.docker_host, "expected_bridge_sha256": pins["bridge_sha256"], "expected_dataset_sha256": protocol["universe"]["selection_jsonl_sha256"], "expected_docker_cli_sha256": pins["docker_cli_sha256"], "expected_docker_daemon_id": pins["docker_daemon_id"], "expected_docker_package_sha256": pins["docker_package_sha256"], "expected_docker_server_version": pins["docker_server_version"], "expected_python_environment_sha256": pins["python_environment_sha256"], "expected_python_sha256": pins["python_sha256"], "expected_revision": pins["revision"], "expected_run_evaluation_sha256": pins["run_evaluation_sha256"], "instance_id": scenario_id, "namespace": pins["namespace"], "swebench_checkout": runtime.swebench_checkout, "swebench_python": runtime.swebench_python, } red_root = work_root / f"official-{slot:03d}-red" try: red_evidence = swebench.verify_swebench( **common_verifier, phase="red", work_dir=red_root, timeout=_remaining(deadline), allow_image_pull=True, ) red_summary = _phase_summary( red_evidence, phase="red", fail_to_pass_count=len(focused), pass_to_pass_count=len(regressions), pins=pins, dataset_sha256=str(protocol["universe"]["selection_jsonl_sha256"]), ) _retain_phase_artifacts( evidence=red_evidence, instance_id=scenario_id, phase="red", source_root=red_root, destination_root=retained_root / f"scenario-{slot:03d}" / "red", summary=red_summary, ) except Exception as exc: raise MaterializationError("official red control failed") from exc image_id = str(red_summary["image_id"]) green_root = work_root / f"official-{slot:03d}-green" try: green_evidence = swebench.verify_swebench( **common_verifier, phase="green", work_dir=green_root, timeout=_remaining(deadline), expected_image_id=image_id, allow_image_pull=False, ) green_summary = _phase_summary( green_evidence, phase="green", fail_to_pass_count=len(focused), pass_to_pass_count=len(regressions), pins=pins, dataset_sha256=str(protocol["universe"]["selection_jsonl_sha256"]), ) if green_summary["image_id"] != image_id: raise MaterializationError("official green image identity drifted") if green_summary["runtime_identity_sha256"] != red_summary["runtime_identity_sha256"]: raise MaterializationError("official verifier runtime identity drifted") _retain_phase_artifacts( evidence=green_evidence, instance_id=scenario_id, phase="green", source_root=green_root, destination_root=retained_root / f"scenario-{slot:03d}" / "green", summary=green_summary, ) except Exception as exc: raise MaterializationError("official green control failed") from exc elapsed = time.monotonic() - started if elapsed > timeout: raise MaterializationError("control verification exceeded the frozen timeout") red_marker = next( ( status for status in ("FAILED", "ERROR") if int(red_summary["status_counts"].get(status, 0)) > 0 ), "", ) if not red_marker: raise MaterializationError("official red control omitted a failure status") task = str(row["problem_statement"]) query = " ".join(task.split())[:240] repo_url = holdout.canonical_repo_url(str(row["repo"])) verify_command = ["{python}", "-m", "pytest", "-q", *focused] regression_command = ["{python}", "-m", "pytest", "-q", *regressions] verifier_binding = { "allowed_paths_sha256": _sha256(_canonical_bytes(production_paths)), "base_commit": commit, "bridge_sha256": pins["bridge_sha256"], "dataset_row_sha256": _sha256(_canonical_bytes(row)), "dataset_sha256": protocol["universe"]["selection_jsonl_sha256"], "docker_cli_sha256": pins["docker_cli_sha256"], "docker_daemon_id_sha256": _sha256(str(pins["docker_daemon_id"]).encode()), "docker_package_sha256": pins["docker_package_sha256"], "docker_server_version": pins["docker_server_version"], "fail_to_pass_sha256": _sha256(_canonical_bytes(focused)), "harness_revision": pins["revision"], "harness_source_sha256": red_evidence["authentication"]["source_sha256"], "image_content_digest": image_id, "pass_to_pass_sha256": _sha256(_canonical_bytes(regressions)), "python_environment_sha256": pins["python_environment_sha256"], "python_sha256": pins["python_sha256"], "repository_tree_sha1": tree, "repository_url": repo_url, "run_evaluation_sha256": pins["run_evaluation_sha256"], "runtime_identity_sha256": red_summary["runtime_identity_sha256"], "schema_version": 1, } scenario_row = { "allowed_changes": production_paths, "benchmark_class": "historical", "commit": commit, "ctx_context": [], "expected_test_count": len(focused), "id": scenario_id, "language": "python", "official_verifier_binding": verifier_binding, "query": query, "red_failure_contains": red_marker, "reference_patch": str(row["patch"]), "regression_verify": [regression_command], "repo_url": repo_url, "reconstructed_test_sha256": test_sha256, "task": task, "test_body": test_source, "test_path": test_path, "verify": verify_command, } scenario = benchmark.Scenario( id=scenario_id, repo_url=repo_url, commit=commit, task=task, query=query, language="python", benchmark_class="historical", test_path=test_path, test_body=test_source, verify=tuple(verify_command), expected_test_count=len(focused), regression_verify=(tuple(regression_command),), red_failure_contains=red_marker, reference_patch=str(row["patch"]), allowed_changes=tuple(production_paths), context=(), ) control = { "changed_test_module_green": True, "elapsed_seconds": round(elapsed, 6), "green_evidence_sha256": green_summary["verifier_evidence_sha256"], "module_evidence_sha256": green_summary["artifact_manifest_sha256"], "official_swebench": { "green": _control_phase_summary(green_summary), "image_id": image_id, "pins_sha256": _sha256(_canonical_bytes(pins)), "red": _control_phase_summary(red_summary), }, "parent_with_test_patch_red": True, "reconstructed_test_sha256": test_sha256, "red_evidence_sha256": red_summary["verifier_evidence_sha256"], "reference_patch_green": True, "timeout_compliant": True, "timeout_seconds": timeout, } return scenario_row, scenario, control, test_source def _validate_output_destination(output: Path) -> None: resolved = output.resolve(strict=False) private_root = (ROOT / ".gate" / "ctx-ab-private").resolve() if ROOT.resolve() in resolved.parents and private_root not in resolved.parents: raise MaterializationError("holdout output inside the repository must use the private root") output.parent.mkdir(mode=0o700, parents=True, exist_ok=True) if output.exists() or output.is_symlink(): raise MaterializationError("holdout output already exists") def _write_artifacts( output: Path, artifacts: dict[str, bytes], *, retained_evidence: Path, ) -> None: _validate_output_destination(output) temp = Path(tempfile.mkdtemp(prefix=".materialize-", dir=output.parent)) os.chmod(temp, 0o700) try: for key, data in artifacts.items(): path = temp / OUTPUT_FILES[key] _private_write(path, data) if stat.S_IMODE(path.stat().st_mode) != 0o600: raise MaterializationError("private artifact permissions are unsafe") retained_evidence.rename(temp / VERIFICATION_DIR) temp.rename(output) except BaseException as exc: cleanup_temp = True published_verification = temp / VERIFICATION_DIR if published_verification.exists() and not retained_evidence.exists(): try: published_verification.rename(retained_evidence) except BaseException as rollback_exc: try: temp.rename(retained_evidence) except BaseException as fallback_exc: cleanup_temp = False exc.add_note( "materialization rollback failed; staged evidence retained at " f"{temp} ({type(rollback_exc).__name__}, " f"{type(fallback_exc).__name__})" ) else: temp = retained_evidence / ".published-output-staging" if cleanup_temp and temp.exists(): shutil.rmtree(temp, ignore_errors=True) raise def materialize( *, protocol_path: Path, expected_acquisition_protocol_sha256: str, exposure_ledger_path: Path, rows_path: Path, selection_path: Path, source_map_path: Path, runtime_availability_path: Path, catalog_archive_path: Path, output: Path, failure_evidence_output: Path, swebench_checkout: Path, swebench_python: Path, docker_cli: Path, docker_host: str, ) -> dict[str, str]: protocol = _load_authenticated_protocol( protocol_path, expected_sha256=expected_acquisition_protocol_sha256, ) try: freezer._paths_are_distinct( { "protocol": protocol_path, "exposure ledger": exposure_ledger_path, "rows": rows_path, "selection": selection_path, "source map": source_map_path, "runtime availability": runtime_availability_path, "catalog archive": catalog_archive_path, "output": output, "failure evidence output": failure_evidence_output, } ) except freezer.FreezeError as exc: raise MaterializationError("materialization inputs must not alias") from exc try: pins = freezer.validate_acquisition_protocol( protocol, benchmark_script_path=Path(benchmark.__file__), catalog_archive_path=catalog_archive_path, runtime_availability_path=runtime_availability_path, ) except freezer.FreezeError as exc: raise MaterializationError( f"materializer requires a valid acquisition-frozen V2 protocol: {exc}" ) from exc try: exposure_document = exposure_ledger.load_authenticated_ledger( exposure_ledger_path, str(protocol["exposure_ledger_sha256"]), ) except (OSError, ValueError) as exc: raise MaterializationError("authenticated exposure ledger is invalid") from exc timeout = protocol["timeouts"]["control_verification_seconds"] rows_bytes = rows_path.read_bytes() rows_sha256 = _sha256(rows_bytes) if rows_sha256 != protocol["universe"].get("selection_jsonl_sha256"): raise MaterializationError("canonical JSONL does not match the acquisition freeze") rows = _load_jsonl(rows_path) if len(rows) != int(protocol["universe"]["expected_rows"]): raise MaterializationError("canonical JSONL row count does not match the protocol") selection_bytes = selection_path.read_bytes() selection = _load_json(selection_path) if selection_bytes != _canonical_bytes(selection): raise MaterializationError("private selection must use canonical JSON bytes") ledger = holdout.reject_historical_exposures( [holdout.evaluate_row(row, protocol) for row in rows], exposure_document, ) if selection != holdout.select_rows(ledger, protocol): raise MaterializationError("private selection does not match deterministic selection") try: holdout.require_exposure_disjoint_selection(selection, exposure_document) except ValueError as exc: raise MaterializationError("private selection intersects historical exposure") from exc selected_ids, repository_map = holdout._validated_selection(selection, protocol) if len(selected_ids) != SCENARIO_COUNT or len(set(repository_map.values())) != SCENARIO_COUNT: raise MaterializationError( "V2 materialization requires exactly ten tasks from ten repositories" ) rows_by_id = {str(row.get("instance_id") or ""): row for row in rows} if len(rows_by_id) != len(rows) or any(item not in rows_by_id for item in selected_ids): raise MaterializationError("selected rows are missing or duplicated") try: sources, _source_map_sha256 = freezer.validate_source_map(source_map_path) except freezer.FreezeError as exc: raise MaterializationError(f"private source map is invalid: {exc}") from exc expected_source_urls = { holdout.canonical_repo_url(str(rows_by_id[scenario_id]["repo"])) for scenario_id in selected_ids } if set(sources) != expected_source_urls: raise MaterializationError("private source map does not match selected repositories") if _sha256(runtime_availability_path.read_bytes()) != protocol["product_inputs"].get( "runtime_availability_sha256" ): raise MaterializationError("runtime availability does not match the product freeze") if _sha256(catalog_archive_path.read_bytes()) != protocol["product_inputs"].get( "catalog_archive_sha256" ): raise MaterializationError("catalog archive does not match the product freeze") runtime = VerifierRuntime( swebench_checkout=swebench_checkout, swebench_python=swebench_python, docker_cli=docker_cli, docker_host=docker_host, ) _validate_runtime(runtime) _validate_output_destination(output) try: failure_evidence.validate_destination( failure_evidence_output, repository_root=ROOT, ) except failure_evidence.FailureEvidenceError as exc: raise MaterializationError("private failure evidence destination is invalid") from exc scenario_rows: list[dict[str, Any]] = [] scenarios: list[benchmark.Scenario] = [] controls: dict[str, Any] = {} reconstructed: dict[str, str] = {} retained_evidence = Path(tempfile.mkdtemp(prefix=".official-verification-", dir=output.parent)) os.chmod(retained_evidence, 0o700) preserve_retained_evidence = False try: work_root = Path(tempfile.mkdtemp(prefix=".ctx-holdout-materialize-", dir=output.parent)) os.chmod(work_root, 0o700) try: source_preflight_deadline = time.monotonic() + float(timeout) for source_bundle in sources.values(): _validate_source_bundle_heads( source_bundle, cwd=work_root, deadline=source_preflight_deadline, ) for slot, scenario_id in enumerate(selected_ids): row = rows_by_id[scenario_id] scenario_row, scenario, control, reconstructed_source = _scenario( row, dataset_path=rows_path.resolve(strict=True), protocol=protocol, pins=pins, retained_root=retained_evidence, runtime=runtime, source=_repo_source(row, sources), slot=slot, work_root=work_root, timeout=float(timeout), ) scenario_rows.append(scenario_row) scenarios.append(scenario) controls[scenario_id] = control reconstructed[scenario_id] = reconstructed_source except BaseException as exc: try: work_root.rename(retained_evidence / "raw-control-work") except BaseException as capture_exc: exc.add_note( "raw control worktree publication failed; " f"staging retained at {work_root} ({type(capture_exc).__name__})" ) raise else: shutil.rmtree(work_root) scenario_pack_bytes = _canonical_bytes({"scenarios": scenario_rows, "version": 1}) scenario_pack_sha256 = _sha256(scenario_pack_bytes) collision: dict[str, Any] = dict( benchmark.validate_runtime_pack_scenario_independence( scenarios, availability_path=runtime_availability_path, archive_path=catalog_archive_path, ) ) collision.update( { "collision_count": 0, "collision_free": True, "scenario_ids": sorted(selected_ids), "scenarios_sha256": scenario_pack_sha256, } ) reconstructed_attestation = holdout.build_reconstructed_test_attestation( selection, protocol, reconstructed, ) selection_sha256 = _sha256(selection_bytes) control_results = { "all_scenarios_passed": len(controls) == SCENARIO_COUNT, "guard": "holdout-control-results-v1", "scenario_count": SCENARIO_COUNT, "scenario_results": controls, "scenario_pack_sha256": scenario_pack_sha256, "selection_sha256": selection_sha256, "verifier_pins_sha256": _sha256(_canonical_bytes(pins)), } artifacts = { "scenario_pack": scenario_pack_bytes, "collision": _canonical_bytes(collision), "reconstructed": _canonical_bytes(reconstructed_attestation), "controls": _canonical_bytes(control_results), } _write_artifacts( output, artifacts, retained_evidence=retained_evidence, ) return {key: _sha256(value) for key, value in artifacts.items()} except BaseException as exc: preserve_retained_evidence = True failure_evidence.publish_failure( staging=retained_evidence, destination=failure_evidence_output, operation="holdout-materialization", exc=exc, repository_root=ROOT, ) raise finally: if retained_evidence.exists() and not preserve_retained_evidence: shutil.rmtree(retained_evidence, ignore_errors=True) def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--protocol", type=Path, required=True) parser.add_argument("--expected-acquisition-protocol-sha256", required=True) parser.add_argument("--exposure-ledger", type=Path, required=True) parser.add_argument("--rows", type=Path, required=True) parser.add_argument("--selection", type=Path, required=True) parser.add_argument("--source-map", type=Path, required=True) parser.add_argument("--runtime-availability", type=Path, required=True) parser.add_argument("--catalog-archive", type=Path, required=True) parser.add_argument("--output", type=Path, required=True) parser.add_argument("--failure-evidence-output", type=Path, required=True) parser.add_argument("--swebench-checkout", type=Path, required=True) parser.add_argument("--swebench-python", type=Path, required=True) parser.add_argument("--docker-cli", type=Path, required=True) parser.add_argument("--docker-host", required=True) args = parser.parse_args(argv) try: failure_evidence.validate_destination( args.failure_evidence_output, repository_root=ROOT, ) except failure_evidence.FailureEvidenceError: parser.exit(2, "materialization precondition failed; evidence=unavailable\n") try: hashes = materialize( protocol_path=args.protocol, expected_acquisition_protocol_sha256=args.expected_acquisition_protocol_sha256, exposure_ledger_path=args.exposure_ledger, rows_path=args.rows, selection_path=args.selection, source_map_path=args.source_map, runtime_availability_path=args.runtime_availability, catalog_archive_path=args.catalog_archive, output=args.output, failure_evidence_output=args.failure_evidence_output, swebench_checkout=args.swebench_checkout, swebench_python=args.swebench_python, docker_cli=args.docker_cli, docker_host=args.docker_host, ) controls = _load_json(args.output / OUTPUT_FILES["controls"]) scenario_count = controls["scenario_count"] except BaseException as exc: evidence_status = "preserved" if not failure_evidence.already_preserved(args.failure_evidence_output): try: failure_evidence.publish_failure( destination=args.failure_evidence_output, operation="holdout-materialization", exc=exc, repository_root=ROOT, ) except BaseException: evidence_status = "unavailable" parser.exit( 2, "materialization failed; private details suppressed " f"({type(exc).__name__}); evidence={evidence_status}\n", ) print( f"materialized {scenario_count} private scenarios; " + " ".join(f"{key}_sha256={value}" for key, value in sorted(hashes.items())) ) return 0 if __name__ == "__main__": raise SystemExit(main())