"""Prepare the reserve-only 1b revision and replay the unchanged guard.""" from copy import deepcopy from functools import partial from pathlib import Path from tempfile import TemporaryDirectory from types import FunctionType from unittest.mock import Mock from phase2_h1_worker_v2 import checked, save, sha import phase3_item1b_fold0 as legacy from s2_gpu_idle_gate import wait_idle ROOT = legacy.ROOT.with_name("phase3-item1b-fold0-wait-reserve-2026-11-19") OLD_BINDING = "ed6bfe113f9c0bf925684a62cf0c1bb09bfc7b1277e06fad628fc0e9e5bcd859" OLD_REVIEW = "0fadd70d365e1015f835fb953691797811a032766d3a9c1b75f3b8e4678faf61" def expected_contract(): checked(legacy.ROOT / "expected-review-binding.json", OLD_BINDING) old = legacy.contract(legacy.ROOT / "contract.json") revised = deepcopy(old) revised["version"] = "phase3-item1b-fold0-screen-wait-reserve-v2" revised["budget"].update(waiting_reserve_gpu_seconds=66, projected_new_gpu_seconds=13186) source = Path(__file__).resolve() revised["code_sha256"][str(source)] = sha(source) return revised def load_contract(path): revision = legacy.read(path) if revision != expected_contract(): raise PermissionError("Only the reserve-only revision is allowed") budget = revision["budget"] reserved = sum(budget[name] for name in ( "train_gpu_seconds", "screen_gpu_seconds", "waiting_reserve_gpu_seconds", "finalization_gpu_seconds")) if (budget["idle_wait_seconds"] != 60 or reserved != budget["projected_new_gpu_seconds"] or budget["prior_item_gpu_seconds"] + reserved > budget["item_gpu_limit_seconds"] or budget["prior_phase3_gpu_seconds"] + reserved > budget["phase3_gpu_limit_seconds"]): raise PermissionError("Revised projection outside original authorization") return revision def replay(path, query_seconds): clock = 0. samples = [] def sleep(seconds): nonlocal clock clock += seconds def snapshot(uuid): samples.append(clock) sleep(query_seconds) return dict(uuid=uuid, idle=False, memory_MiB=1500, occupants=[]) dispatch = Mock(side_effect=AssertionError("Busy-card path must not dispatch")) guarded = legacy.dispatch_guard # The same compiled guard and the same shared wait run here. Only the # recovery contract loader and the CPU simulation boundaries are supplied. namespace = dict( guarded.__globals__, contract=load_contract, snapshot=snapshot, wait_idle=partial(wait_idle, clock=lambda: clock, sleep=sleep), supervise=dispatch) guard = FunctionType(guarded.__code__, namespace, guarded.__name__) with TemporaryDirectory(prefix="meltmind-fold0-busy-replay-") as scratch: out = Path(scratch) returned = guard(out, path) result = legacy.read(out / "complete.json") if not (returned == 1 and result["trigger"] == "IDLE_TIMEOUT" and dispatch.call_count == 0): raise RuntimeError(f"Unexpected busy replay at {query_seconds} seconds") return dict(query_seconds=query_seconds, sample_start_seconds=samples, terminal=result["trigger"], dispatches=dispatch.call_count, booked_wait_gpu_seconds=result["queue_wait_gpu_seconds"], within_revised_reserve=result["queue_wait_gpu_seconds"] <= 66) def prepare(): old_review_path = ROOT.parent / "meltassist-item1b-fold0-screen-review-2026-11-19/review.json" checked(old_review_path, OLD_REVIEW) ROOT.mkdir(exist_ok=False) path = ROOT / "contract.json" save(path, expected_contract()) cases = [replay(path, seconds) for seconds in (2., 6., 6.01)] if (not all(case["within_revised_reserve"] for case in cases[:2]) or cases[2]["within_revised_reserve"]): raise RuntimeError("Boundary and overhead witness differ from expectation") receipt = dict( status="BLOCKED_WAIT_RESERVE_NOT_HARD_BOUND", old_binding_sha256=OLD_BINDING, old_independent_review_sha256=OLD_REVIEW, actual_revised_contract_sha256=sha(path), unchanged_guard_sha256=sha(legacy.__file__), cases=cases, deadline_seconds=60, waiting_reserve_gpu_seconds=66, revised_total_gpu_seconds=13186, observation="Two 3s subprocess timeouts do not bound process setup, result collection " "or scheduler overhead of the complete snapshot.", proposals_evaluated=["2 seconds for full query", "3 seconds per subquery", "3 seconds per subquery plus 10ms outside subprocess timeouts"], training_scope_unchanged=True, actual_worker_dispatched=False, launch_ready=False) save(ROOT / "cpu-guard-wait-replay.json", receipt) print(receipt) if __name__ == "__main__": prepare()