diff --git a/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/audit-attempt1.txt b/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/audit-attempt1.txt new file mode 100644 index 000000000..d48f0c50e --- /dev/null +++ b/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/audit-attempt1.txt @@ -0,0 +1,2 @@ +Session 18717, chunk f164d6, failed the final-charge assertion after passing the late-sample and late-recheck assertions. +The audit installed the synthetic clock through a mock side effect, so its caller-frame hook did not target the guard's final charge line. Installing the clock as a direct replacement corrected the synthetic fault injection. The production guard and binding were untouched. diff --git a/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/audit.py b/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/audit.py new file mode 100644 index 000000000..b6aa8aaf4 --- /dev/null +++ b/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/audit.py @@ -0,0 +1,136 @@ +"""Reproduce late confirm/recheck and final-ledger boundaries using frozen 1b code.""" + +from functools import partial +import hashlib +import inspect +import json +from pathlib import Path +from tempfile import TemporaryDirectory +from unittest.mock import patch + +import phase3_item1b_fold0 as entry +from phase2_home_freeze_io import verify +from s2_gpu_idle_gate import wait_idle + +OUT = Path(__file__).resolve().parent +ORIGINAL_REVIEW = OUT.parent/'meltassist-item1b-fold0-screen-review-2026-11-19/review.json' +CONTRACT = entry.ROOT/'contract.json' + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def read(path): + return json.loads(path.read_text()) + + +class InertMonitor: + """Avoid clock races with the synthetic watch thread; test coordinator dispatch.""" + + def __init__(self, **kwargs): + pass + + def start(self): + pass + + def join(self, **kwargs): + pass + + def is_alive(self): + return False + + +def simulate(contract, *, latency, recheck_latency, complete_mock_phases=False): + now = 0. + samples = [] + dispatches = [] + original_save = entry.save + code, code_line = inspect.getsourcelines(entry.dispatch_guard) + final_charge_line = next(code_line+i for i,line in enumerate(code) + if 'charges["finalization_gpu_seconds"] = max(' in line) + + def sleep(seconds): + nonlocal now + now += seconds + + def clock(): + if complete_mock_phases and inspect.currentframe().f_back.f_lineno == final_charge_line: + sleep(23.) # Scheduling delay after screen overhead check, before final ledger. + return now + + def sample(uuid): + index = len(samples) + samples.append(now) + sleep(latency if index < 6 else recheck_latency) + return dict(uuid=uuid, idle=index >= 3, memory_MiB=5 if index>=3 else 1500, occupants=[]) + + def save(path, payload): + original_save(path, payload) + if complete_mock_phases and path.name=='training-adopted.json': + sleep(119.) # Stay below the existing 120s finalization allowance on the check. + + def fake_dispatch(command, root, mode, limits, *, poll, gpu_uuid): + dispatches.append(dict(mode=mode, seconds=now)) + if not complete_mock_phases: + raise RuntimeError('Synthetic dispatch intercepted; no child process') + sleep(limits['job_wall_seconds'] - .1) + output = root/('jobs/0/worker' if mode=='train' else 'screen') + output.mkdir() + result = dict(status='COMPLETE',test_targets_read=False,peak_allocated_bytes=32,peak_reserved_bytes=64) + if mode=='train': + checkpoint = output/'mock.pt' + checkpoint.write_bytes(b'synthetic') + result.update(fold=0,completed_epochs=100,optimizer_steps=contract['job']['target_steps'], + checkpoint=str(checkpoint),checkpoint_sha256=sha(checkpoint)) + else: + result.update(parts=len(contract['job']['validation']),automatic_continuation=False,decision='SCREEN_PASS') + original_save(output/'result.json',result) + return dict(status='PASS',returncode=0,monitor_errors=0) + + with TemporaryDirectory(prefix='meltassist-1b-final-boundary-') as temp: + root = Path(temp) + with (patch.object(entry,'snapshot',side_effect=sample), + patch.object(entry,'wait_idle',partial(wait_idle,clock=clock,sleep=sleep)), + patch.object(entry.time,'monotonic',new=clock), + patch.object(entry.threading,'Thread',InertMonitor), + patch.object(entry,'supervise',side_effect=fake_dispatch), + patch.object(entry,'save',side_effect=save)): + code = entry.dispatch_guard(root,CONTRACT) + gate = read(root/'idle-gate.json') + terminal = read(root/'complete.json') + return dict(gate=gate['status'], gate_seconds=gate['wall_seconds'], + snapshot_start_seconds=samples, mock_dispatches=dispatches, returned=code, + status=terminal['status'], trigger=terminal['trigger'], + charges={k:terminal[k] for k in ('queue_wait_gpu_seconds','training_gpu_seconds', + 'screen_gpu_seconds','finalization_gpu_seconds')}, + new_gpu_seconds=terminal['cumulative_item_gpu_seconds']-contract['budget']['prior_item_gpu_seconds']) + + +contract = entry.contract(CONTRACT) +binding_path = entry.ROOT/'expected-review-binding.json' +binding = read(binding_path) +proof = verify(entry.ROOT,'implementation') +assert sha(binding_path)=='ed6bfe113f9c0bf925684a62cf0c1bb09bfc7b1277e06fad628fc0e9e5bcd859' +assert binding['contract_sha256']==sha(CONTRACT) and binding['reviewed_commit']==proof['commit'] +assert sha(ORIGINAL_REVIEW)=='0fadd70d365e1015f835fb953691797811a032766d3a9c1b75f3b8e4678faf61' + +late_confirmation = simulate(contract,latency=2.,recheck_latency=2.) +assert late_confirmation['gate']=='IDLE_TIMEOUT' and late_confirmation['gate_seconds']==62. +assert late_confirmation['mock_dispatches']==[] and len(late_confirmation['snapshot_start_seconds'])==6 +late_recheck = simulate(contract,latency=1.5,recheck_latency=1.5) +assert late_recheck['gate']=='IDLE_CONFIRMED' and late_recheck['gate_seconds']==59. +assert late_recheck['mock_dispatches']==[dict(mode='train',seconds=62.)] +terminal_delay = simulate(contract,latency=1.5,recheck_latency=0.,complete_mock_phases=True) +assert terminal_delay['returned']==0 and terminal_delay['status']=='COMPLETE' +assert terminal_delay['new_gpu_seconds'] > contract['budget']['projected_new_gpu_seconds'] + +evidence = dict(binding=binding,binding_file_sha256=sha(binding_path),old_blocked_review_sha256=sha(ORIGINAL_REVIEW), + ruling='h-ebe17c6b',actual_execution_contract=str(CONTRACT), + late_confirmation=late_confirmation,late_recheck=late_recheck, + terminal_delay=terminal_delay,actual_start_exists=(entry.ROOT/'started.json').exists(), + real_gpu_query=False,real_worker_started=False,targets_read=False) +with (OUT/'evidence.json').open('x') as f: + json.dump(evidence,f,indent=2) + f.write('\n') +print({k:v for k,v in evidence.items() if k!='binding'}) diff --git a/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/evidence.json b/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/evidence.json new file mode 100644 index 000000000..7edeab13b --- /dev/null +++ b/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/evidence.json @@ -0,0 +1,169 @@ +{ + "binding": { + "reviewed_commit": "a92d0cf7742bd1fc1309d1baadf5e2fcf7a1db6e", + "contract_sha256": "942323ddfceecf47515eb48628c45157073cbb909867a606ef4d3764a13be7d4", + "implementation_proof_sha256": "5036ea9570ebccd064013f98e8ad0d314504d297f9afb9893e8582a632147b1e", + "comparison_contract_sha256": "bd71a5a6a0f3a288267f568cbb85d1cea5ab6fa0485e7fd212cd55e36f664954", + "code_sha256": { + "/home/frank14f/optane/MeltMind/tools/freeze_g1_components.py": "d0cee60d95243ac2c59ef3f2244ba818315718c4e3d1895f2f9f064f1f7f5ecd", + "/home/frank14f/optane/MeltMind/tools/gre24_models.py": "53b6fee8b700b9b982b06d29908ce2ce23e0c57512c46dbf74b2aade79e3ac3a", + "/home/frank14f/optane/MeltMind/tools/phase2_gate_outcome_review.py": "915617aeb8292d03c654e637bc34a014c254fd178a773f135d1806c4b41372a8", + "/home/frank14f/optane/MeltMind/tools/phase2_h1_worker_v2.py": "1543df85b615bb69b79bacd572074a7c77ae19dab110197601573a7e5805ed20", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_data.py": "7e03dd7a94e7bb43593277f183c222473d7cb7aaf2f60e53b45ab8d9499fcb09", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_model.py": "fab2470dd0654ca74c3b7d893f35ad1f3ae6c5c08ffe334ef6312cf6ec87892a", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_pilot_worker.py": "14651ca402e6d02466d8afdb77bc9e62fb2e752f0c0c3d20d98593157d5ebe81", + "/home/frank14f/optane/MeltMind/tools/phase2_home_freeze_io.py": "bf09204b85ed2a7038acdd202257f618474d1110a9d6d772f105a3ffb334d3ff", + "/home/frank14f/optane/MeltMind/tools/phase2_local_freeze_io.py": "60adf3382577613c5234f5cf30779336b9951b66e90c075cb7cd0adab9cc42dd", + "/home/frank14f/optane/MeltMind/tools/phase2_residual_math.py": "ffbd9624dec79bdaabf95244fe87209055908f31a977e73ea4377045d6f8fe62", + "/home/frank14f/optane/MeltMind/tools/phase3_item1_postfit_data.py": "de9cbcc147677c9144c706acbe52c0f7d505dad17d741d86dcbd04d052f940e2", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_common.py": "4e25effe8326ff8c7c3f751590315040209af054b32b0505dc3c6b001589db32", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_fold0.py": "1446919f2274bc6207527ad80cbd634e47761f9d6391543d420d4f8cd6498527", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_schedule.py": "06cb97594c3a87f42f712dcde6cec8c2d90e0b50a89a6be7954bdd2f5c18d5de", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_worker.py": "b781e56c519401bd38af6a522deb24506cba6993d2af008f85ea4e1715f1d9c6", + "/home/frank14f/optane/MeltMind/tools/phase3_seed1_v2_common.py": "25ca6be14027369393bd3616209b08f30e25892cccca83300483c5a116e8d75d", + "/home/frank14f/optane/MeltMind/tools/phase3_shared_capacity.py": "7c07b0aaf1bc4e6a980d016defcac326c3bd871134d2583bb4dcd88bb34728f8", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item1b_fold0.py": "f48ebe3e3aeca03e5d4cbdd532061cfb27362ec84e85dae70e77e22b4e40b8e0", + "/home/frank14f/optane/MeltMind/tools/s2_custody_common.py": "588c646101be0d50f505f9a12a1c98361aa3437c8c594eecb7321831f717a741", + "/home/frank14f/optane/MeltMind/tools/s2_gpu_idle_gate.py": "e2b1613e7e6ea398a8d555220a9365a1ad998ab4ef4b2bf8ec7cc4e31f8b4b9f", + "/home/frank14f/optane/MeltMind/tools/s2_main_memory_guard.py": "e094f5443e11518efe9018215c11718a8e18aa462a977bf43e974b2d0b2aebb1", + "/home/frank14f/optane/MeltMind/tools/s2_models/__init__.py": "a0fa1323d3553172da66c5d442c5fc4fcb0d5055c886c776928604550ea97609", + "/home/frank14f/optane/MeltMind/tools/s2_models/attention.py": "7714adfccf6a0fc6b52a44aee3a50321a88898bf3d743680a1108c01e1ff8a61", + "/home/frank14f/optane/MeltMind/tools/s2_models/blocks.py": "b13e986cea5f1d7f325a1638c1505197b4a105baacff5a9a515f23fcaf28ea75", + "/home/frank14f/optane/MeltMind/tools/s2_models/features.py": "3b34ae61cf8012ebd58b7505a73d7aa43d8ee1890ac54f98d7917b67887a45a4", + "/home/frank14f/optane/MeltMind/tools/s2_models/network.py": "5137e845d81d1223afc13bf87e03ccba1132a3baa75d5189a8f320b2752be071", + "/home/frank14f/optane/MeltMind/tools/s2_models/normalization.py": "7180696d3845799e28d8c31ddef957d075de6a2e46d96a3a0f0df16fc05234a0", + "/home/frank14f/optane/MeltMind/tools/s2_models/objectives.py": "5b6527a45f08690055d572335470ce5979e8bb86e1cab00de594f79ae21316b1", + "/home/frank14f/optane/MeltMind/tools/s2_pilot_train.py": "e9cceead51a5cc092aad23409ad98909c84a62e7e10571e750d1e9be1ad3b948", + "/home/frank14f/optane/MeltMind/tools/s2_precision_continuation_guard.py": "01235d897c7c03e5ffa109c58b14f5d24d128e8f1ba873e1f76cfb14e02f7a7f", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_gpu_supervisor.py": "689c0f3179e4fcd362e546d90214829a9e4f8739abdbdf74b560763e5a392f15", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_monitoring.py": "442c2a9c75e8c00b30a8f2e91cb52d87c466b19a80aea9128b10c021e61b922e", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_common.py": "79918e7de887d1f0a2de5523156b27d00dc2d85ac930a07efc34d817d904fe65", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_prepare.py": "f657be036dc48fc5936f56c4b8510a4b295d4787af6877cc5ccaad663107be17", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_capacity.py": "771faad0095712fd4fc8131ddcfabaa3901141592d2b055ea2faadf8ea3d3edf", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_guard.py": "08b7d8ab2ac773fab8b749f9f61af259254422128e9634f8b715c81efce2651f", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_queue.py": "31dfd71369c63512c1d6fe176fd22e8db646520c92da533bb5530ca3843c388d", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item1b.py": "c7bc9f3b7cf4137f52e1efad19dcb7045282d4e9a9c1aae50f066c9e488f7c01", + "/home/frank14f/optane/MeltMind/tools/test_phase3_item1b.py": "b4d78f4384651711fe83ff00eb6719c6c61664699d801ecb34978b9546439da9", + "/home/frank14f/optane/MeltMind/tools/track_a_recovery_monitor.py": "4c423f8b0dff69304d0046c0a9c319bb31aa0c6d1cbaeb3942726b5e6caa0496", + "/home/frank14f/optane/MeltMind/tools/track_a_recovery_supervisor.py": "5ccb2a6eec95b0700b2063a2f8df414037528e90c206648c1c5e49c5e89e741d", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_common.py": "38a29a34663a5d6310571eeff53b5d18a0355e51b9fa58a08033f64fa379a9df", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_common.py": "4e85f5d211c4d3e2188422aa4c0cefa40dcfa14ef32e90894ed3412de1fd1d12", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_data.py": "fe3aa3e023f22f4fe55cd47e7ffa677b58f52a041867ac05620cbd329d913cb6", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_guard.py": "7144fa77ffe61a2a3c92c050234e370ef4dfeb0e31fafb419f752f969737ff1a", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_loss.py": "79e291866bda300ecdc5577c62903d34abeec14f5cc36db05e346f9ffd64c24b", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_queue.py": "a04879cc0169ecb523a88360cddca1e234d91b3adbc20b3ec31d02461ed767eb", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_worker.py": "0f8f35e1422021b2a4f097c2e62267fb935fe4658fd0ee8ccd251609a4062ea7", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item_c.py": "782c415b1f536eb2b85aa2c9c4a9a0dc278f9b7134e8a83e2a6af8199396c53a", + "/home/frank14f/optane/MeltMind/tools/s2_custody_statistics.py": "188565801f6901d0192f79aec0889e632501e672a4149d76d1835efbb9b45447", + "/home/frank14f/optane/MeltMind/tools/test_phase3_item_c.py": "3115aa9049974eac86657aa4cee7b5d716f6ee93268555cc86242029ebefce4c", + "/home/frank14f/optane/MeltMind/tools/test_phase2_h2_s2.py": "4235890fd194b7778e937f0be9245b964512df2c75d962ef703e3a988c5b8805", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_guard.py": "6bc7624b0cfe850591f77153cd2034eefdd62f7e63b93211ccdb87eb8aba346c", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_common.py": "308486507ae3589a0e6cc40565f6e60e6d2f63ae74c4d828bdacf33b3b8b8062", + "/home/frank14f/optane/MeltMind/tools/phase2_fixed_io.py": "ea17fdfc7508f3f980e3cdf69534b1eb8ceb8a8e469c32451b2d5e16d0ada575", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_worker.py": "37dfd75fff50b3d65f4ef37f4255536616582fe5f3d01155a0e037325ab5c7cd", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_worker.py": "ecee04b183ef2b93b7b39a447d48c40a5843d3190e48d2d7eb4939811a5db9b0", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_prepare.py": "964fae13ac95e4de4dc50b3c0a80791d86349ce3a9f3c5a6e7dc3cf8ca041fad", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_prepare.py": "3a31af0766f628a80f38e0b7286beb11ca3109188eabc4adfdb2ecb0eef3dc27", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_queue.py": "d82dfb365956e08250758bb4c651a19fbecce92fe209072f5f8ed35970450735", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_launch.py": "480fac25dea5a2006bb84130a4b0a0b253b3040b2150a56c38eada62b2c259e6", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_guard.py": "ae94711adc17a7630f398e8d4120fa3cc8f60979a00122c4cd2dc364c382ced5", + "/home/frank14f/optane/MeltMind/docs/phase2-h2-s2-execution-contract-2026-11-17.md": "1e8e5ef31650519737cd6cd247abc0bd04744dd93ffb013eff88866d42f03073" + } + }, + "binding_file_sha256": "ed6bfe113f9c0bf925684a62cf0c1bb09bfc7b1277e06fad628fc0e9e5bcd859", + "old_blocked_review_sha256": "0fadd70d365e1015f835fb953691797811a032766d3a9c1b75f3b8e4678faf61", + "ruling": "h-ebe17c6b", + "actual_execution_contract": "/home/frank14f/optane/MeltMind/artifacts/phase3-item1b-fold0-screen-2026-11-19/contract.json", + "late_confirmation": { + "gate": "IDLE_TIMEOUT", + "gate_seconds": 62.0, + "snapshot_start_seconds": [ + 0.0, + 12.0, + 24.0, + 36.0, + 48.0, + 60.0 + ], + "mock_dispatches": [], + "returned": 1, + "status": "STOPPED", + "trigger": "IDLE_TIMEOUT", + "charges": { + "queue_wait_gpu_seconds": 62.0, + "training_gpu_seconds": 0.0, + "screen_gpu_seconds": 0.0, + "finalization_gpu_seconds": 0.0 + }, + "new_gpu_seconds": 62.0 + }, + "late_recheck": { + "gate": "IDLE_CONFIRMED", + "gate_seconds": 59.0, + "snapshot_start_seconds": [ + 0.0, + 11.5, + 23.0, + 34.5, + 46.0, + 57.5, + 59.0, + 60.5 + ], + "mock_dispatches": [ + { + "mode": "train", + "seconds": 62.0 + } + ], + "returned": 1, + "status": "STOPPED", + "trigger": "RuntimeError: Synthetic dispatch intercepted; no child process", + "charges": { + "queue_wait_gpu_seconds": 59.0, + "training_gpu_seconds": 1.5, + "screen_gpu_seconds": 0.0, + "finalization_gpu_seconds": 1.5 + }, + "new_gpu_seconds": 62.0 + }, + "terminal_delay": { + "gate": "IDLE_CONFIRMED", + "gate_seconds": 59.0, + "snapshot_start_seconds": [ + 0.0, + 11.5, + 23.0, + 34.5, + 46.0, + 57.5, + 59.0, + 59.0, + 12984.9 + ], + "mock_dispatches": [ + { + "mode": "train", + "seconds": 59.0 + }, + { + "mode": "screen", + "seconds": 12984.9 + } + ], + "returned": 0, + "status": "COMPLETE", + "trigger": "SCREEN_PASS", + "charges": { + "queue_wait_gpu_seconds": 59.0, + "training_gpu_seconds": 12806.9, + "screen_gpu_seconds": 172.89999999999964, + "finalization_gpu_seconds": 142.0 + }, + "new_gpu_seconds": 13180.8 + }, + "actual_start_exists": false, + "real_gpu_query": false, + "real_worker_started": false, + "targets_read": false +} diff --git a/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/review.json b/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/review.json new file mode 100644 index 000000000..d4dab319f --- /dev/null +++ b/artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/review.json @@ -0,0 +1,100 @@ +{ + "reviewed_commit": "a92d0cf7742bd1fc1309d1baadf5e2fcf7a1db6e", + "contract_sha256": "942323ddfceecf47515eb48628c45157073cbb909867a606ef4d3764a13be7d4", + "implementation_proof_sha256": "5036ea9570ebccd064013f98e8ad0d314504d297f9afb9893e8582a632147b1e", + "comparison_contract_sha256": "bd71a5a6a0f3a288267f568cbb85d1cea5ab6fa0485e7fd212cd55e36f664954", + "code_sha256": { + "/home/frank14f/optane/MeltMind/tools/freeze_g1_components.py": "d0cee60d95243ac2c59ef3f2244ba818315718c4e3d1895f2f9f064f1f7f5ecd", + "/home/frank14f/optane/MeltMind/tools/gre24_models.py": "53b6fee8b700b9b982b06d29908ce2ce23e0c57512c46dbf74b2aade79e3ac3a", + "/home/frank14f/optane/MeltMind/tools/phase2_gate_outcome_review.py": "915617aeb8292d03c654e637bc34a014c254fd178a773f135d1806c4b41372a8", + "/home/frank14f/optane/MeltMind/tools/phase2_h1_worker_v2.py": "1543df85b615bb69b79bacd572074a7c77ae19dab110197601573a7e5805ed20", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_data.py": "7e03dd7a94e7bb43593277f183c222473d7cb7aaf2f60e53b45ab8d9499fcb09", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_model.py": "fab2470dd0654ca74c3b7d893f35ad1f3ae6c5c08ffe334ef6312cf6ec87892a", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_pilot_worker.py": "14651ca402e6d02466d8afdb77bc9e62fb2e752f0c0c3d20d98593157d5ebe81", + "/home/frank14f/optane/MeltMind/tools/phase2_home_freeze_io.py": "bf09204b85ed2a7038acdd202257f618474d1110a9d6d772f105a3ffb334d3ff", + "/home/frank14f/optane/MeltMind/tools/phase2_local_freeze_io.py": "60adf3382577613c5234f5cf30779336b9951b66e90c075cb7cd0adab9cc42dd", + "/home/frank14f/optane/MeltMind/tools/phase2_residual_math.py": "ffbd9624dec79bdaabf95244fe87209055908f31a977e73ea4377045d6f8fe62", + "/home/frank14f/optane/MeltMind/tools/phase3_item1_postfit_data.py": "de9cbcc147677c9144c706acbe52c0f7d505dad17d741d86dcbd04d052f940e2", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_common.py": "4e25effe8326ff8c7c3f751590315040209af054b32b0505dc3c6b001589db32", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_fold0.py": "1446919f2274bc6207527ad80cbd634e47761f9d6391543d420d4f8cd6498527", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_schedule.py": "06cb97594c3a87f42f712dcde6cec8c2d90e0b50a89a6be7954bdd2f5c18d5de", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_worker.py": "b781e56c519401bd38af6a522deb24506cba6993d2af008f85ea4e1715f1d9c6", + "/home/frank14f/optane/MeltMind/tools/phase3_seed1_v2_common.py": "25ca6be14027369393bd3616209b08f30e25892cccca83300483c5a116e8d75d", + "/home/frank14f/optane/MeltMind/tools/phase3_shared_capacity.py": "7c07b0aaf1bc4e6a980d016defcac326c3bd871134d2583bb4dcd88bb34728f8", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item1b_fold0.py": "f48ebe3e3aeca03e5d4cbdd532061cfb27362ec84e85dae70e77e22b4e40b8e0", + "/home/frank14f/optane/MeltMind/tools/s2_custody_common.py": "588c646101be0d50f505f9a12a1c98361aa3437c8c594eecb7321831f717a741", + "/home/frank14f/optane/MeltMind/tools/s2_gpu_idle_gate.py": "e2b1613e7e6ea398a8d555220a9365a1ad998ab4ef4b2bf8ec7cc4e31f8b4b9f", + "/home/frank14f/optane/MeltMind/tools/s2_main_memory_guard.py": "e094f5443e11518efe9018215c11718a8e18aa462a977bf43e974b2d0b2aebb1", + "/home/frank14f/optane/MeltMind/tools/s2_models/__init__.py": "a0fa1323d3553172da66c5d442c5fc4fcb0d5055c886c776928604550ea97609", + "/home/frank14f/optane/MeltMind/tools/s2_models/attention.py": "7714adfccf6a0fc6b52a44aee3a50321a88898bf3d743680a1108c01e1ff8a61", + "/home/frank14f/optane/MeltMind/tools/s2_models/blocks.py": "b13e986cea5f1d7f325a1638c1505197b4a105baacff5a9a515f23fcaf28ea75", + "/home/frank14f/optane/MeltMind/tools/s2_models/features.py": "3b34ae61cf8012ebd58b7505a73d7aa43d8ee1890ac54f98d7917b67887a45a4", + "/home/frank14f/optane/MeltMind/tools/s2_models/network.py": "5137e845d81d1223afc13bf87e03ccba1132a3baa75d5189a8f320b2752be071", + "/home/frank14f/optane/MeltMind/tools/s2_models/normalization.py": "7180696d3845799e28d8c31ddef957d075de6a2e46d96a3a0f0df16fc05234a0", + "/home/frank14f/optane/MeltMind/tools/s2_models/objectives.py": "5b6527a45f08690055d572335470ce5979e8bb86e1cab00de594f79ae21316b1", + "/home/frank14f/optane/MeltMind/tools/s2_pilot_train.py": "e9cceead51a5cc092aad23409ad98909c84a62e7e10571e750d1e9be1ad3b948", + "/home/frank14f/optane/MeltMind/tools/s2_precision_continuation_guard.py": "01235d897c7c03e5ffa109c58b14f5d24d128e8f1ba873e1f76cfb14e02f7a7f", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_gpu_supervisor.py": "689c0f3179e4fcd362e546d90214829a9e4f8739abdbdf74b560763e5a392f15", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_monitoring.py": "442c2a9c75e8c00b30a8f2e91cb52d87c466b19a80aea9128b10c021e61b922e", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_common.py": "79918e7de887d1f0a2de5523156b27d00dc2d85ac930a07efc34d817d904fe65", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_prepare.py": "f657be036dc48fc5936f56c4b8510a4b295d4787af6877cc5ccaad663107be17", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_capacity.py": "771faad0095712fd4fc8131ddcfabaa3901141592d2b055ea2faadf8ea3d3edf", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_guard.py": "08b7d8ab2ac773fab8b749f9f61af259254422128e9634f8b715c81efce2651f", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_queue.py": "31dfd71369c63512c1d6fe176fd22e8db646520c92da533bb5530ca3843c388d", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item1b.py": "c7bc9f3b7cf4137f52e1efad19dcb7045282d4e9a9c1aae50f066c9e488f7c01", + "/home/frank14f/optane/MeltMind/tools/test_phase3_item1b.py": "b4d78f4384651711fe83ff00eb6719c6c61664699d801ecb34978b9546439da9", + "/home/frank14f/optane/MeltMind/tools/track_a_recovery_monitor.py": "4c423f8b0dff69304d0046c0a9c319bb31aa0c6d1cbaeb3942726b5e6caa0496", + "/home/frank14f/optane/MeltMind/tools/track_a_recovery_supervisor.py": "5ccb2a6eec95b0700b2063a2f8df414037528e90c206648c1c5e49c5e89e741d", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_common.py": "38a29a34663a5d6310571eeff53b5d18a0355e51b9fa58a08033f64fa379a9df", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_common.py": "4e85f5d211c4d3e2188422aa4c0cefa40dcfa14ef32e90894ed3412de1fd1d12", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_data.py": "fe3aa3e023f22f4fe55cd47e7ffa677b58f52a041867ac05620cbd329d913cb6", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_guard.py": "7144fa77ffe61a2a3c92c050234e370ef4dfeb0e31fafb419f752f969737ff1a", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_loss.py": "79e291866bda300ecdc5577c62903d34abeec14f5cc36db05e346f9ffd64c24b", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_queue.py": "a04879cc0169ecb523a88360cddca1e234d91b3adbc20b3ec31d02461ed767eb", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_worker.py": "0f8f35e1422021b2a4f097c2e62267fb935fe4658fd0ee8ccd251609a4062ea7", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item_c.py": "782c415b1f536eb2b85aa2c9c4a9a0dc278f9b7134e8a83e2a6af8199396c53a", + "/home/frank14f/optane/MeltMind/tools/s2_custody_statistics.py": "188565801f6901d0192f79aec0889e632501e672a4149d76d1835efbb9b45447", + "/home/frank14f/optane/MeltMind/tools/test_phase3_item_c.py": "3115aa9049974eac86657aa4cee7b5d716f6ee93268555cc86242029ebefce4c", + "/home/frank14f/optane/MeltMind/tools/test_phase2_h2_s2.py": "4235890fd194b7778e937f0be9245b964512df2c75d962ef703e3a988c5b8805", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_guard.py": "6bc7624b0cfe850591f77153cd2034eefdd62f7e63b93211ccdb87eb8aba346c", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_common.py": "308486507ae3589a0e6cc40565f6e60e6d2f63ae74c4d828bdacf33b3b8b8062", + "/home/frank14f/optane/MeltMind/tools/phase2_fixed_io.py": "ea17fdfc7508f3f980e3cdf69534b1eb8ceb8a8e469c32451b2d5e16d0ada575", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_worker.py": "37dfd75fff50b3d65f4ef37f4255536616582fe5f3d01155a0e037325ab5c7cd", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_worker.py": "ecee04b183ef2b93b7b39a447d48c40a5843d3190e48d2d7eb4939811a5db9b0", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_prepare.py": "964fae13ac95e4de4dc50b3c0a80791d86349ce3a9f3c5a6e7dc3cf8ca041fad", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_prepare.py": "3a31af0766f628a80f38e0b7286beb11ca3109188eabc4adfdb2ecb0eef3dc27", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_queue.py": "d82dfb365956e08250758bb4c651a19fbecce92fe209072f5f8ed35970450735", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_launch.py": "480fac25dea5a2006bb84130a4b0a0b253b3040b2150a56c38eada62b2c259e6", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_guard.py": "ae94711adc17a7630f398e8d4120fa3cc8f60979a00122c4cd2dc364c382ced5", + "/home/frank14f/optane/MeltMind/docs/phase2-h2-s2-execution-contract-2026-11-17.md": "1e8e5ef31650519737cd6cd247abc0bd04744dd93ffb013eff88866d42f03073" + }, + "verdict": "BLOCKED", + "reviewer": "MeltAssist", + "scope": "Original a92d0cf execution binding under superseding Claude h-ebe17c6b. Only late-idle dispatch and hard cumulative cap.", + "evidence_sha256": "f687e4e0f883e2418b5438d552db5fb9959d8b012926fae3ba08dbc053b71130", + "audit_sha256": "920f05d1bb8cb439a8e064d50284d5de68a19d461620c4ace8580e3633cf2755", + "original_review_sha256": "0fadd70d365e1015f835fb953691797811a032766d3a9c1b75f3b8e4678faf61", + "findings": [ + { + "id": "ITEM1B-DEADLINE-POSTCONFIRM-RECHECK", + "priority": "P1", + "file": "tools/phase3_item1b_fold0.py", + "line": 245, + "observed": "Late third idle sample returning at62s fails closed with one in-flight query and zero dispatch. However, third confirmation returning at59s is followed by two unbounded-to-deadline rechecks starting at59s and60.5s. The actual guard calls the mocked training supervisor at62s. No deadline check before supervise.", + "requested_fix": "Keep accepted measured wait overrun as evidence, but carry the original dispatch deadline through the post-confirmation rechecks and check before training supervisor dispatch. No revised cap needed." + }, + { + "id": "ITEM1B-FINAL-CHARGE-CAP-UNCHECKED", + "priority": "P1", + "file": "tools/phase3_item1b_fold0.py", + "line": 340, + "observed": "The coordinator returns success after the last overhead check. Its finally block takes a new measured finalization charge and writes terminal status without a combined cap check. A synthetic 23s scheduling pause only at the final clock read after the 119s overhead check, with phase charges below their limits, yields exit0/COMPLETE and actual new charge13180.8>13180.", + "requested_fix": "Evaluate the settled measured sum once before assigning final status and return code, preserving the measured receipt and classifying an overshoot as a budget stop." + } + ], + "limitations": [ + "Tests exercised the frozen contract and guard with a synthetic clock, device snapshots, inert watch thread and intercepted supervisor. No real job, scientific computation or targets.", + "First reviewer replay used a mock wrapper that intercepted the caller frame and missed the injected pause; corrected and kept the failed attempt separately.", + "Earlier narrow candidate PASS was for reserve accounting evidence. The 66-second candidate is archived under h-ebe17c6b. Ordinary 62s timeout with zero dispatch is accepted by the updated rule." + ] +} diff --git a/artifacts/meltassist-item1b-wait-reserve-narrow-review-2026-11-19/audit.py b/artifacts/meltassist-item1b-wait-reserve-narrow-review-2026-11-19/audit.py new file mode 100644 index 000000000..2506ede73 --- /dev/null +++ b/artifacts/meltassist-item1b-wait-reserve-narrow-review-2026-11-19/audit.py @@ -0,0 +1,81 @@ +"""Check the reserve-only candidate under Claude's revised wait criterion.""" + +from copy import deepcopy +import hashlib +import json +from pathlib import Path + +import phase3_item1b_fold0 as legacy +from prepare_phase3_item1b_fold0_wait_reserve import ROOT, load_contract, replay + +OUT = Path(__file__).resolve().parent + + +def read(path): + return json.loads(Path(path).read_text()) + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +path = ROOT / 'contract.json' +binding_path = ROOT / 'expected-narrow-review-binding.json' +binding = read(binding_path) +assert sha(binding_path) == '6543c14749faafba094a3e78f3e27061b31d425e9112dc10ae6f82705729f665' +assert sha(path) == binding['contract_sha256'] == '2146c67bf073735c47b0a8f877226ee003b228b764944887a3402518b1729299' +assert binding['reviewed_commit'] == '8d5c498e3be25580cf022890add6b32d7d6b8a93' +assert binding['launch_ready'] is False and 'implementation_proof_sha256' not in binding +c = load_contract(path) +old_path = legacy.ROOT / 'contract.json' +old = read(old_path) +assert c['code_sha256'] == binding['code_sha256'] and len(c['code_sha256']) == 64 +for f,h in c['code_sha256'].items(): + assert sha(f) == h +assert c['comparison_contract_sha256'] == binding['comparison_contract_sha256'] == sha(c['comparison_contract']) +assert sha(legacy.ROOT/'expected-review-binding.json') == binding['old_blocked_binding_sha256'] +old_review = OUT.parent/'meltassist-item1b-fold0-screen-review-2026-11-19/review.json' +assert sha(old_review) == binding['old_review_sha256'] and read(old_review)['verdict'] == 'BLOCKED' +restored = deepcopy(c) +restored['version'] = old['version'] +added_code = set(c['code_sha256']) - set(old['code_sha256']) +assert len(added_code) == 1 and next(iter(added_code)).endswith('/prepare_phase3_item1b_fold0_wait_reserve.py') +for key in added_code: + del restored['code_sha256'][key] +assert restored['budget'].pop('waiting_reserve_gpu_seconds') == 66 +assert restored['budget']['projected_new_gpu_seconds'] == 13186 +restored['budget']['projected_new_gpu_seconds'] = 13180 +assert (json.dumps(restored,indent=2,allow_nan=False)+'\n').encode() == old_path.read_bytes() +b = c['budget'] +assert b['idle_wait_seconds'] == 60 +assert b['train_gpu_seconds'] + b['screen_gpu_seconds'] + b['waiting_reserve_gpu_seconds'] + b['finalization_gpu_seconds'] == b['projected_new_gpu_seconds'] == 13186 +assert b['prior_item_gpu_seconds'] + 13186 <= b['item_gpu_limit_seconds'] +assert b['prior_phase3_gpu_seconds'] + 13186 <= b['phase3_gpu_limit_seconds'] + +frozen_path = ROOT / 'cpu-guard-wait-replay.json' +frozen = read(frozen_path) +assert sha(frozen_path) == binding['guard_replay_sha256'] +assert sha(legacy.__file__) == frozen['unchanged_guard_sha256'] +replays = [replay(path, seconds) for seconds in (2., 6., 6.01)] +assert replays == frozen['cases'] +assert [r['booked_wait_gpu_seconds'] for r in replays] == [62., 66., 66.01] +assert all(r['dispatches']==0 and r['terminal']=='IDLE_TIMEOUT' for r in replays) +assert all(r['sample_start_seconds'][-1]==60. for r in replays) + +try: + legacy.contract(path) +except PermissionError as exc: + legacy_status = str(exc) +else: + raise AssertionError('Candidate unexpectedly passed old running loader') +assert 'remaining budget exceeded' in legacy_status +state = {n:(ROOT/n).exists() for n in ('expected-review-binding.json','implementation-git-freeze.json','review.json','started.json','jobs','screen')} +evidence = dict(binding=binding, binding_file_sha256=sha(binding_path), + context='Claude h-f84547d7; 66 seconds is a planning reserve', + original_delta_removed_contract_byte_identical=True, deadline=60, reserved_wait=66, + cumulative_cap=13186, cases=replays, legacy_execution_loader_rejects=legacy_status, + candidate_entry_state=state, real_gpu_query=False, real_worker_started=False, targets_read=False) +with (OUT/'evidence.json').open('x') as f: + json.dump(evidence,f,indent=2) + f.write('\n') +print({k:v for k,v in evidence.items() if k!='binding'}) diff --git a/artifacts/meltassist-item1b-wait-reserve-narrow-review-2026-11-19/evidence.json b/artifacts/meltassist-item1b-wait-reserve-narrow-review-2026-11-19/evidence.json new file mode 100644 index 000000000..ac722c567 --- /dev/null +++ b/artifacts/meltassist-item1b-wait-reserve-narrow-review-2026-11-19/evidence.json @@ -0,0 +1,140 @@ +{ + "binding": { + "reviewed_commit": "8d5c498e3be25580cf022890add6b32d7d6b8a93", + "contract_sha256": "2146c67bf073735c47b0a8f877226ee003b228b764944887a3402518b1729299", + "comparison_contract_sha256": "bd71a5a6a0f3a288267f568cbb85d1cea5ab6fa0485e7fd212cd55e36f664954", + "code_sha256": { + "/home/frank14f/optane/MeltMind/tools/freeze_g1_components.py": "d0cee60d95243ac2c59ef3f2244ba818315718c4e3d1895f2f9f064f1f7f5ecd", + "/home/frank14f/optane/MeltMind/tools/gre24_models.py": "53b6fee8b700b9b982b06d29908ce2ce23e0c57512c46dbf74b2aade79e3ac3a", + "/home/frank14f/optane/MeltMind/tools/phase2_gate_outcome_review.py": "915617aeb8292d03c654e637bc34a014c254fd178a773f135d1806c4b41372a8", + "/home/frank14f/optane/MeltMind/tools/phase2_h1_worker_v2.py": "1543df85b615bb69b79bacd572074a7c77ae19dab110197601573a7e5805ed20", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_data.py": "7e03dd7a94e7bb43593277f183c222473d7cb7aaf2f60e53b45ab8d9499fcb09", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_model.py": "fab2470dd0654ca74c3b7d893f35ad1f3ae6c5c08ffe334ef6312cf6ec87892a", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_pilot_worker.py": "14651ca402e6d02466d8afdb77bc9e62fb2e752f0c0c3d20d98593157d5ebe81", + "/home/frank14f/optane/MeltMind/tools/phase2_home_freeze_io.py": "bf09204b85ed2a7038acdd202257f618474d1110a9d6d772f105a3ffb334d3ff", + "/home/frank14f/optane/MeltMind/tools/phase2_local_freeze_io.py": "60adf3382577613c5234f5cf30779336b9951b66e90c075cb7cd0adab9cc42dd", + "/home/frank14f/optane/MeltMind/tools/phase2_residual_math.py": "ffbd9624dec79bdaabf95244fe87209055908f31a977e73ea4377045d6f8fe62", + "/home/frank14f/optane/MeltMind/tools/phase3_item1_postfit_data.py": "de9cbcc147677c9144c706acbe52c0f7d505dad17d741d86dcbd04d052f940e2", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_common.py": "4e25effe8326ff8c7c3f751590315040209af054b32b0505dc3c6b001589db32", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_fold0.py": "1446919f2274bc6207527ad80cbd634e47761f9d6391543d420d4f8cd6498527", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_schedule.py": "06cb97594c3a87f42f712dcde6cec8c2d90e0b50a89a6be7954bdd2f5c18d5de", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_worker.py": "b781e56c519401bd38af6a522deb24506cba6993d2af008f85ea4e1715f1d9c6", + "/home/frank14f/optane/MeltMind/tools/phase3_seed1_v2_common.py": "25ca6be14027369393bd3616209b08f30e25892cccca83300483c5a116e8d75d", + "/home/frank14f/optane/MeltMind/tools/phase3_shared_capacity.py": "7c07b0aaf1bc4e6a980d016defcac326c3bd871134d2583bb4dcd88bb34728f8", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item1b_fold0.py": "f48ebe3e3aeca03e5d4cbdd532061cfb27362ec84e85dae70e77e22b4e40b8e0", + "/home/frank14f/optane/MeltMind/tools/s2_custody_common.py": "588c646101be0d50f505f9a12a1c98361aa3437c8c594eecb7321831f717a741", + "/home/frank14f/optane/MeltMind/tools/s2_gpu_idle_gate.py": "e2b1613e7e6ea398a8d555220a9365a1ad998ab4ef4b2bf8ec7cc4e31f8b4b9f", + "/home/frank14f/optane/MeltMind/tools/s2_main_memory_guard.py": "e094f5443e11518efe9018215c11718a8e18aa462a977bf43e974b2d0b2aebb1", + "/home/frank14f/optane/MeltMind/tools/s2_models/__init__.py": "a0fa1323d3553172da66c5d442c5fc4fcb0d5055c886c776928604550ea97609", + "/home/frank14f/optane/MeltMind/tools/s2_models/attention.py": "7714adfccf6a0fc6b52a44aee3a50321a88898bf3d743680a1108c01e1ff8a61", + "/home/frank14f/optane/MeltMind/tools/s2_models/blocks.py": "b13e986cea5f1d7f325a1638c1505197b4a105baacff5a9a515f23fcaf28ea75", + "/home/frank14f/optane/MeltMind/tools/s2_models/features.py": "3b34ae61cf8012ebd58b7505a73d7aa43d8ee1890ac54f98d7917b67887a45a4", + "/home/frank14f/optane/MeltMind/tools/s2_models/network.py": "5137e845d81d1223afc13bf87e03ccba1132a3baa75d5189a8f320b2752be071", + "/home/frank14f/optane/MeltMind/tools/s2_models/normalization.py": "7180696d3845799e28d8c31ddef957d075de6a2e46d96a3a0f0df16fc05234a0", + "/home/frank14f/optane/MeltMind/tools/s2_models/objectives.py": "5b6527a45f08690055d572335470ce5979e8bb86e1cab00de594f79ae21316b1", + "/home/frank14f/optane/MeltMind/tools/s2_pilot_train.py": "e9cceead51a5cc092aad23409ad98909c84a62e7e10571e750d1e9be1ad3b948", + "/home/frank14f/optane/MeltMind/tools/s2_precision_continuation_guard.py": "01235d897c7c03e5ffa109c58b14f5d24d128e8f1ba873e1f76cfb14e02f7a7f", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_gpu_supervisor.py": "689c0f3179e4fcd362e546d90214829a9e4f8739abdbdf74b560763e5a392f15", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_monitoring.py": "442c2a9c75e8c00b30a8f2e91cb52d87c466b19a80aea9128b10c021e61b922e", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_common.py": "79918e7de887d1f0a2de5523156b27d00dc2d85ac930a07efc34d817d904fe65", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_prepare.py": "f657be036dc48fc5936f56c4b8510a4b295d4787af6877cc5ccaad663107be17", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_capacity.py": "771faad0095712fd4fc8131ddcfabaa3901141592d2b055ea2faadf8ea3d3edf", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_guard.py": "08b7d8ab2ac773fab8b749f9f61af259254422128e9634f8b715c81efce2651f", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_queue.py": "31dfd71369c63512c1d6fe176fd22e8db646520c92da533bb5530ca3843c388d", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item1b.py": "c7bc9f3b7cf4137f52e1efad19dcb7045282d4e9a9c1aae50f066c9e488f7c01", + "/home/frank14f/optane/MeltMind/tools/test_phase3_item1b.py": "b4d78f4384651711fe83ff00eb6719c6c61664699d801ecb34978b9546439da9", + "/home/frank14f/optane/MeltMind/tools/track_a_recovery_monitor.py": "4c423f8b0dff69304d0046c0a9c319bb31aa0c6d1cbaeb3942726b5e6caa0496", + "/home/frank14f/optane/MeltMind/tools/track_a_recovery_supervisor.py": "5ccb2a6eec95b0700b2063a2f8df414037528e90c206648c1c5e49c5e89e741d", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_common.py": "38a29a34663a5d6310571eeff53b5d18a0355e51b9fa58a08033f64fa379a9df", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_common.py": "4e85f5d211c4d3e2188422aa4c0cefa40dcfa14ef32e90894ed3412de1fd1d12", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_data.py": "fe3aa3e023f22f4fe55cd47e7ffa677b58f52a041867ac05620cbd329d913cb6", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_guard.py": "7144fa77ffe61a2a3c92c050234e370ef4dfeb0e31fafb419f752f969737ff1a", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_loss.py": "79e291866bda300ecdc5577c62903d34abeec14f5cc36db05e346f9ffd64c24b", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_queue.py": "a04879cc0169ecb523a88360cddca1e234d91b3adbc20b3ec31d02461ed767eb", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_worker.py": "0f8f35e1422021b2a4f097c2e62267fb935fe4658fd0ee8ccd251609a4062ea7", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item_c.py": "782c415b1f536eb2b85aa2c9c4a9a0dc278f9b7134e8a83e2a6af8199396c53a", + "/home/frank14f/optane/MeltMind/tools/s2_custody_statistics.py": "188565801f6901d0192f79aec0889e632501e672a4149d76d1835efbb9b45447", + "/home/frank14f/optane/MeltMind/tools/test_phase3_item_c.py": "3115aa9049974eac86657aa4cee7b5d716f6ee93268555cc86242029ebefce4c", + "/home/frank14f/optane/MeltMind/tools/test_phase2_h2_s2.py": "4235890fd194b7778e937f0be9245b964512df2c75d962ef703e3a988c5b8805", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_guard.py": "6bc7624b0cfe850591f77153cd2034eefdd62f7e63b93211ccdb87eb8aba346c", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_common.py": "308486507ae3589a0e6cc40565f6e60e6d2f63ae74c4d828bdacf33b3b8b8062", + "/home/frank14f/optane/MeltMind/tools/phase2_fixed_io.py": "ea17fdfc7508f3f980e3cdf69534b1eb8ceb8a8e469c32451b2d5e16d0ada575", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_worker.py": "37dfd75fff50b3d65f4ef37f4255536616582fe5f3d01155a0e037325ab5c7cd", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_worker.py": "ecee04b183ef2b93b7b39a447d48c40a5843d3190e48d2d7eb4939811a5db9b0", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_prepare.py": "964fae13ac95e4de4dc50b3c0a80791d86349ce3a9f3c5a6e7dc3cf8ca041fad", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_prepare.py": "3a31af0766f628a80f38e0b7286beb11ca3109188eabc4adfdb2ecb0eef3dc27", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_queue.py": "d82dfb365956e08250758bb4c651a19fbecce92fe209072f5f8ed35970450735", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_launch.py": "480fac25dea5a2006bb84130a4b0a0b253b3040b2150a56c38eada62b2c259e6", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_guard.py": "ae94711adc17a7630f398e8d4120fa3cc8f60979a00122c4cd2dc364c382ced5", + "/home/frank14f/optane/MeltMind/docs/phase2-h2-s2-execution-contract-2026-11-17.md": "1e8e5ef31650519737cd6cd247abc0bd04744dd93ffb013eff88866d42f03073", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item1b_fold0_wait_reserve.py": "1ac9f722205526f85cc78d630f4366046e51cb486db9973706c3b281941332ee" + }, + "guard_replay_sha256": "97d252cb4a699c1cfffe91b92f64210a5d135e0a067f29cec89aed306556af91", + "old_blocked_binding_sha256": "ed6bfe113f9c0bf925684a62cf0c1bb09bfc7b1277e06fad628fc0e9e5bcd859", + "old_review_sha256": "0fadd70d365e1015f835fb953691797811a032766d3a9c1b75f3b8e4678faf61", + "launch_ready": false + }, + "binding_file_sha256": "6543c14749faafba094a3e78f3e27061b31d425e9112dc10ae6f82705729f665", + "context": "Claude h-f84547d7; 66 seconds is a planning reserve", + "original_delta_removed_contract_byte_identical": true, + "deadline": 60, + "reserved_wait": 66, + "cumulative_cap": 13186, + "cases": [ + { + "query_seconds": 2.0, + "sample_start_seconds": [ + 0.0, + 12.0, + 24.0, + 36.0, + 48.0, + 60.0 + ], + "terminal": "IDLE_TIMEOUT", + "dispatches": 0, + "booked_wait_gpu_seconds": 62.0, + "within_revised_reserve": true + }, + { + "query_seconds": 6.0, + "sample_start_seconds": [ + 0.0, + 16.0, + 32.0, + 48.0, + 60.0 + ], + "terminal": "IDLE_TIMEOUT", + "dispatches": 0, + "booked_wait_gpu_seconds": 66.0, + "within_revised_reserve": true + }, + { + "query_seconds": 6.01, + "sample_start_seconds": [ + 0.0, + 16.009999999999998, + 32.019999999999996, + 48.029999999999994, + 60.0 + ], + "terminal": "IDLE_TIMEOUT", + "dispatches": 0, + "booked_wait_gpu_seconds": 66.01, + "within_revised_reserve": false + } + ], + "legacy_execution_loader_rejects": "Phase 3 or 1b remaining budget exceeded", + "candidate_entry_state": { + "expected-review-binding.json": false, + "implementation-git-freeze.json": false, + "review.json": false, + "started.json": false, + "jobs": false, + "screen": false + }, + "real_gpu_query": false, + "real_worker_started": false, + "targets_read": false +} diff --git a/artifacts/meltassist-item1b-wait-reserve-narrow-review-2026-11-19/review.json b/artifacts/meltassist-item1b-wait-reserve-narrow-review-2026-11-19/review.json new file mode 100644 index 000000000..bfd36e962 --- /dev/null +++ b/artifacts/meltassist-item1b-wait-reserve-narrow-review-2026-11-19/review.json @@ -0,0 +1,93 @@ +{ + "reviewed_commit": "8d5c498e3be25580cf022890add6b32d7d6b8a93", + "contract_sha256": "2146c67bf073735c47b0a8f877226ee003b228b764944887a3402518b1729299", + "comparison_contract_sha256": "bd71a5a6a0f3a288267f568cbb85d1cea5ab6fa0485e7fd212cd55e36f664954", + "code_sha256": { + "/home/frank14f/optane/MeltMind/tools/freeze_g1_components.py": "d0cee60d95243ac2c59ef3f2244ba818315718c4e3d1895f2f9f064f1f7f5ecd", + "/home/frank14f/optane/MeltMind/tools/gre24_models.py": "53b6fee8b700b9b982b06d29908ce2ce23e0c57512c46dbf74b2aade79e3ac3a", + "/home/frank14f/optane/MeltMind/tools/phase2_gate_outcome_review.py": "915617aeb8292d03c654e637bc34a014c254fd178a773f135d1806c4b41372a8", + "/home/frank14f/optane/MeltMind/tools/phase2_h1_worker_v2.py": "1543df85b615bb69b79bacd572074a7c77ae19dab110197601573a7e5805ed20", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_data.py": "7e03dd7a94e7bb43593277f183c222473d7cb7aaf2f60e53b45ab8d9499fcb09", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_model.py": "fab2470dd0654ca74c3b7d893f35ad1f3ae6c5c08ffe334ef6312cf6ec87892a", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_pilot_worker.py": "14651ca402e6d02466d8afdb77bc9e62fb2e752f0c0c3d20d98593157d5ebe81", + "/home/frank14f/optane/MeltMind/tools/phase2_home_freeze_io.py": "bf09204b85ed2a7038acdd202257f618474d1110a9d6d772f105a3ffb334d3ff", + "/home/frank14f/optane/MeltMind/tools/phase2_local_freeze_io.py": "60adf3382577613c5234f5cf30779336b9951b66e90c075cb7cd0adab9cc42dd", + "/home/frank14f/optane/MeltMind/tools/phase2_residual_math.py": "ffbd9624dec79bdaabf95244fe87209055908f31a977e73ea4377045d6f8fe62", + "/home/frank14f/optane/MeltMind/tools/phase3_item1_postfit_data.py": "de9cbcc147677c9144c706acbe52c0f7d505dad17d741d86dcbd04d052f940e2", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_common.py": "4e25effe8326ff8c7c3f751590315040209af054b32b0505dc3c6b001589db32", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_fold0.py": "1446919f2274bc6207527ad80cbd634e47761f9d6391543d420d4f8cd6498527", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_schedule.py": "06cb97594c3a87f42f712dcde6cec8c2d90e0b50a89a6be7954bdd2f5c18d5de", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_worker.py": "b781e56c519401bd38af6a522deb24506cba6993d2af008f85ea4e1715f1d9c6", + "/home/frank14f/optane/MeltMind/tools/phase3_seed1_v2_common.py": "25ca6be14027369393bd3616209b08f30e25892cccca83300483c5a116e8d75d", + "/home/frank14f/optane/MeltMind/tools/phase3_shared_capacity.py": "7c07b0aaf1bc4e6a980d016defcac326c3bd871134d2583bb4dcd88bb34728f8", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item1b_fold0.py": "f48ebe3e3aeca03e5d4cbdd532061cfb27362ec84e85dae70e77e22b4e40b8e0", + "/home/frank14f/optane/MeltMind/tools/s2_custody_common.py": "588c646101be0d50f505f9a12a1c98361aa3437c8c594eecb7321831f717a741", + "/home/frank14f/optane/MeltMind/tools/s2_gpu_idle_gate.py": "e2b1613e7e6ea398a8d555220a9365a1ad998ab4ef4b2bf8ec7cc4e31f8b4b9f", + "/home/frank14f/optane/MeltMind/tools/s2_main_memory_guard.py": "e094f5443e11518efe9018215c11718a8e18aa462a977bf43e974b2d0b2aebb1", + "/home/frank14f/optane/MeltMind/tools/s2_models/__init__.py": "a0fa1323d3553172da66c5d442c5fc4fcb0d5055c886c776928604550ea97609", + "/home/frank14f/optane/MeltMind/tools/s2_models/attention.py": "7714adfccf6a0fc6b52a44aee3a50321a88898bf3d743680a1108c01e1ff8a61", + "/home/frank14f/optane/MeltMind/tools/s2_models/blocks.py": "b13e986cea5f1d7f325a1638c1505197b4a105baacff5a9a515f23fcaf28ea75", + "/home/frank14f/optane/MeltMind/tools/s2_models/features.py": "3b34ae61cf8012ebd58b7505a73d7aa43d8ee1890ac54f98d7917b67887a45a4", + "/home/frank14f/optane/MeltMind/tools/s2_models/network.py": "5137e845d81d1223afc13bf87e03ccba1132a3baa75d5189a8f320b2752be071", + "/home/frank14f/optane/MeltMind/tools/s2_models/normalization.py": "7180696d3845799e28d8c31ddef957d075de6a2e46d96a3a0f0df16fc05234a0", + "/home/frank14f/optane/MeltMind/tools/s2_models/objectives.py": "5b6527a45f08690055d572335470ce5979e8bb86e1cab00de594f79ae21316b1", + "/home/frank14f/optane/MeltMind/tools/s2_pilot_train.py": "e9cceead51a5cc092aad23409ad98909c84a62e7e10571e750d1e9be1ad3b948", + "/home/frank14f/optane/MeltMind/tools/s2_precision_continuation_guard.py": "01235d897c7c03e5ffa109c58b14f5d24d128e8f1ba873e1f76cfb14e02f7a7f", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_gpu_supervisor.py": "689c0f3179e4fcd362e546d90214829a9e4f8739abdbdf74b560763e5a392f15", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_monitoring.py": "442c2a9c75e8c00b30a8f2e91cb52d87c466b19a80aea9128b10c021e61b922e", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_common.py": "79918e7de887d1f0a2de5523156b27d00dc2d85ac930a07efc34d817d904fe65", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_prepare.py": "f657be036dc48fc5936f56c4b8510a4b295d4787af6877cc5ccaad663107be17", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_capacity.py": "771faad0095712fd4fc8131ddcfabaa3901141592d2b055ea2faadf8ea3d3edf", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_guard.py": "08b7d8ab2ac773fab8b749f9f61af259254422128e9634f8b715c81efce2651f", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_queue.py": "31dfd71369c63512c1d6fe176fd22e8db646520c92da533bb5530ca3843c388d", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item1b.py": "c7bc9f3b7cf4137f52e1efad19dcb7045282d4e9a9c1aae50f066c9e488f7c01", + "/home/frank14f/optane/MeltMind/tools/test_phase3_item1b.py": "b4d78f4384651711fe83ff00eb6719c6c61664699d801ecb34978b9546439da9", + "/home/frank14f/optane/MeltMind/tools/track_a_recovery_monitor.py": "4c423f8b0dff69304d0046c0a9c319bb31aa0c6d1cbaeb3942726b5e6caa0496", + "/home/frank14f/optane/MeltMind/tools/track_a_recovery_supervisor.py": "5ccb2a6eec95b0700b2063a2f8df414037528e90c206648c1c5e49c5e89e741d", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_common.py": "38a29a34663a5d6310571eeff53b5d18a0355e51b9fa58a08033f64fa379a9df", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_common.py": "4e85f5d211c4d3e2188422aa4c0cefa40dcfa14ef32e90894ed3412de1fd1d12", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_data.py": "fe3aa3e023f22f4fe55cd47e7ffa677b58f52a041867ac05620cbd329d913cb6", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_guard.py": "7144fa77ffe61a2a3c92c050234e370ef4dfeb0e31fafb419f752f969737ff1a", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_loss.py": "79e291866bda300ecdc5577c62903d34abeec14f5cc36db05e346f9ffd64c24b", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_queue.py": "a04879cc0169ecb523a88360cddca1e234d91b3adbc20b3ec31d02461ed767eb", + "/home/frank14f/optane/MeltMind/tools/phase3_item_c_worker.py": "0f8f35e1422021b2a4f097c2e62267fb935fe4658fd0ee8ccd251609a4062ea7", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item_c.py": "782c415b1f536eb2b85aa2c9c4a9a0dc278f9b7134e8a83e2a6af8199396c53a", + "/home/frank14f/optane/MeltMind/tools/s2_custody_statistics.py": "188565801f6901d0192f79aec0889e632501e672a4149d76d1835efbb9b45447", + "/home/frank14f/optane/MeltMind/tools/test_phase3_item_c.py": "3115aa9049974eac86657aa4cee7b5d716f6ee93268555cc86242029ebefce4c", + "/home/frank14f/optane/MeltMind/tools/test_phase2_h2_s2.py": "4235890fd194b7778e937f0be9245b964512df2c75d962ef703e3a988c5b8805", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_guard.py": "6bc7624b0cfe850591f77153cd2034eefdd62f7e63b93211ccdb87eb8aba346c", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_common.py": "308486507ae3589a0e6cc40565f6e60e6d2f63ae74c4d828bdacf33b3b8b8062", + "/home/frank14f/optane/MeltMind/tools/phase2_fixed_io.py": "ea17fdfc7508f3f980e3cdf69534b1eb8ceb8a8e469c32451b2d5e16d0ada575", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_worker.py": "37dfd75fff50b3d65f4ef37f4255536616582fe5f3d01155a0e037325ab5c7cd", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_worker.py": "ecee04b183ef2b93b7b39a447d48c40a5843d3190e48d2d7eb4939811a5db9b0", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_prepare.py": "964fae13ac95e4de4dc50b3c0a80791d86349ce3a9f3c5a6e7dc3cf8ca041fad", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_prepare.py": "3a31af0766f628a80f38e0b7286beb11ca3109188eabc4adfdb2ecb0eef3dc27", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s2_queue.py": "d82dfb365956e08250758bb4c651a19fbecce92fe209072f5f8ed35970450735", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_launch.py": "480fac25dea5a2006bb84130a4b0a0b253b3040b2150a56c38eada62b2c259e6", + "/home/frank14f/optane/MeltMind/tools/phase2_h2_s1_guard.py": "ae94711adc17a7630f398e8d4120fa3cc8f60979a00122c4cd2dc364c382ced5", + "/home/frank14f/optane/MeltMind/docs/phase2-h2-s2-execution-contract-2026-11-17.md": "1e8e5ef31650519737cd6cd247abc0bd04744dd93ffb013eff88866d42f03073", + "/home/frank14f/optane/MeltMind/tools/prepare_phase3_item1b_fold0_wait_reserve.py": "1ac9f722205526f85cc78d630f4366046e51cb486db9973706c3b281941332ee" + }, + "guard_replay_sha256": "97d252cb4a699c1cfffe91b92f64210a5d135e0a067f29cec89aed306556af91", + "old_blocked_binding_sha256": "ed6bfe113f9c0bf925684a62cf0c1bb09bfc7b1277e06fad628fc0e9e5bcd859", + "old_review_sha256": "0fadd70d365e1015f835fb953691797811a032766d3a9c1b75f3b8e4678faf61", + "launch_ready": false, + "verdict": "PASS", + "scope": "Narrow evidence review only, per superseding Claude h-f84547d7", + "reviewer": "MeltAssist", + "candidate_binding_sha256": "6543c14749faafba094a3e78f3e27061b31d425e9112dc10ae6f82705729f665", + "evidence_sha256": "c1d6a9113f5d3b1f260b04ad70a6d716e14a9edbc9ca2fe027035b51d16085aa", + "audit_sha256": "3938ccba3855b721311322f424c42c84b3ef46189045a910aa737c1ff59c8321", + "eligible_for_runtime_adoption": false, + "findings": [], + "passed_checks": [ + "The candidate retains the 60 second idle decision deadline. Any sampled overrun terminates after the one in-flight snapshot. Measured wall time is booked under queue waiting.", + "Independently re-ran the actual guard with the candidate accounting loader and 2.0/6.0/6.01 second simulated busy queries. Booked62/66/66.01 with zero dispatches in all three. Last poll starts at60 in each.", + "Claude h-f84547d7 supersedes the booked wait<=66 condition. 66.01 is acceptable under the new criterion. 66 is a planning reserve and the cumulative cap is13186. Timeout returns before either worker dispatch; successful admission requires confirmed idle within60.", + "64 code hashes match. Guard and comparison bytes unchanged. Removing the reserve-only metadata changes reconstructs the original contract byte-for-byte. Old BLOCKED review remains preserved." + ], + "runtime_dependency": "The evidence set is not a runnable exact binding. No implementation proof or standard expected-review-binding exists for the candidate. The unmodified production loader still sums idle_wait_seconds=60 rather than waiting_reserve_gpu_seconds=66 and rejects the candidate contract. The completed narrow evidence check is not a runtime review receipt or launch approval.", + "real_gpu_query": false, + "real_worker_started": false, + "targets_read": false +} diff --git a/artifacts/phase3-item1b-fold0-waiver-blocker-2026-11-19/adoption-check.json b/artifacts/phase3-item1b-fold0-waiver-blocker-2026-11-19/adoption-check.json new file mode 100644 index 000000000..10a8aadfe --- /dev/null +++ b/artifacts/phase3-item1b-fold0-waiver-blocker-2026-11-19/adoption-check.json @@ -0,0 +1,47 @@ +{ + "status": "ADOPTION_BLOCKED_BY_ORIGINAL_GATE", + "native_ruling": "h-b951c2d8", + "new_gpu_seconds": 0, + "existing_fold0_cap_gpu_seconds": 13180, + "original_binding_sha256": "ed6bfe113f9c0bf925684a62cf0c1bb09bfc7b1277e06fad628fc0e9e5bcd859", + "independent_review_sha256": "d45ac966f612236656f9b1a0d59ed2f60493c2da0b3c31279e189d7dfa217e35", + "independent_verdict": "BLOCKED", + "five_field_match": { + "reviewed_commit": true, + "contract_sha256": true, + "implementation_proof_sha256": true, + "comparison_contract_sha256": true, + "code_sha256": true + }, + "independent_findings_verbatim": [ + { + "id": "ITEM1B-DEADLINE-POSTCONFIRM-RECHECK", + "priority": "P1", + "file": "tools/phase3_item1b_fold0.py", + "line": 245, + "observed": "Late third idle sample returning at62s fails closed with one in-flight query and zero dispatch. However, third confirmation returning at59s is followed by two unbounded-to-deadline rechecks starting at59s and60.5s. The actual guard calls the mocked training supervisor at62s. No deadline check before supervise.", + "requested_fix": "Keep accepted measured wait overrun as evidence, but carry the original dispatch deadline through the post-confirmation rechecks and check before training supervisor dispatch. No revised cap needed." + }, + { + "id": "ITEM1B-FINAL-CHARGE-CAP-UNCHECKED", + "priority": "P1", + "file": "tools/phase3_item1b_fold0.py", + "line": 340, + "observed": "The coordinator returns success after the last overhead check. Its finally block takes a new measured finalization charge and writes terminal status without a combined cap check. A synthetic 23s scheduling pause only at the final clock read after the 119s overhead check, with phase charges below their limits, yields exit0/COMPLETE and actual new charge13180.8>13180.", + "requested_fix": "Evaluate the settled measured sum once before assigning final status and return code, preserving the measured receipt and classifying an overshoot as a budget stop." + } + ], + "claude_waiver": { + "scope": "Only the two findings in d45ac966 for this exact attempt", + "idle_reason": "The card was already confirmed idle at 59 seconds and the later checks reduce dispatch risk. The 60-second decision is to bound waiting on busy cards.", + "settlement_reason": "Per-phase limits still protect the run. Any overage at final settlement is retained and reported as actual, outside the 13180 cap." + }, + "production_entry": "tools/phase3_item1b_fold0.py:360", + "production_gate": "tools/phase2_gate_outcome_review.py:12", + "exact_error": "Actual exact PASS required", + "synthetic_acceptance_check": "Original gate with the exact BLOCKED receipt and frozen inputs in scratch", + "runtime_receipt_adopted": false, + "run_root_modified": false, + "gpu_queried": false, + "worker_started": false +} diff --git a/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/actual-guard-cpu-preflight.json b/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/actual-guard-cpu-preflight.json new file mode 100644 index 000000000..d5743ba72 --- /dev/null +++ b/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/actual-guard-cpu-preflight.json @@ -0,0 +1,42 @@ +{ + "status": "PASS", + "actual_contract_sha256": "139fec49b7e4627b55ad12f3a129bec75ecc2446811c23a24f376dae207094aa", + "cases": [ + { + "scenario": "idle", + "synthetic_worker_dispatches": 1, + "status": "COMPLETE", + "trigger": null, + "booked_idle_seconds": 20.0, + "charged_gpu_wall_seconds": 22.0 + }, + { + "scenario": "busy", + "synthetic_worker_dispatches": 0, + "status": "STOPPED", + "trigger": "IDLE_DEADLINE", + "booked_idle_seconds": 62.0, + "charged_gpu_wall_seconds": 62.0 + }, + { + "scenario": "late_final_check", + "synthetic_worker_dispatches": 0, + "status": "STOPPED", + "trigger": "IDLE_DEADLINE_AFTER_FINAL_CHECK", + "booked_idle_seconds": 62.0, + "charged_gpu_wall_seconds": 62.0 + }, + { + "scenario": "total_cap", + "synthetic_worker_dispatches": 1, + "status": "STOPPED", + "trigger": "TOTAL_GPU_WALL_CAP", + "booked_idle_seconds": 20.0, + "charged_gpu_wall_seconds": 3600.8 + } + ], + "real_gpu_queries": 0, + "real_workers": 0, + "scientific_arrays_read": false, + "does_not_supply_measured_epoch_seconds": true +} diff --git a/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/comparison-contract.json b/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/comparison-contract.json new file mode 100644 index 000000000..37820e1bf --- /dev/null +++ b/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/comparison-contract.json @@ -0,0 +1,72 @@ +{ + "ruling": "h-f84547d7", + "protocol": { + "model": "NeurIPS 2023 supplement SDFFNOGNO decoder", + "seeds": [ + 0, + 1, + 2 + ], + "grid": [ + 64, + 64, + 64 + ], + "modes": [ + 24, + 24, + 24 + ], + "hidden_channels": 32, + "radius": 0.05, + "epochs_per_seed": 100, + "batch_size": 1, + "learning_rate": 0.001, + "bounds_expansion": 0.01, + "pressure_epsilon": 1e-06, + "optimizer": "Adam", + "weight_decay": 0.0001, + "lr_step_epochs": 50, + "lr_gamma": 0.5, + "pressure_training_transform": "scalar Gaussian on the 500 learning cases", + "metric": "per-case L2(predicted minus true decoded pressure) / L2(true decoded pressure)", + "report": "equal mean over 111 cases for each seed, then equal mean over the three seeds", + "acceptance_percent": [ + 6.62, + 7.62 + ], + "paper_reference_percent": 7.12, + "checkpoint_epoch": 100, + "heldout_access_after_all_checkpoints_frozen": true + }, + "paper_code_zip_sha256": "347a6f097e2b9958d1ab87930fa1d6227b793a9d213e12418ce9a157e83dce04", + "source_protocol_commit": "8d5c498e3be25580cf022890add6b32d7d6b8a93", + "split_sha256": "5a96c25c2ec24cfc1e2264d4ebd0879c658c0f168e22711b576bf303151b8601", + "audited_mapping_sha256": "055d008a02494acd29df36c41c8e68db931a027f5635e8f5f765a96a54c62289", + "environment": { + "python": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/runtime/bin/python", + "python_version": "3.10", + "torch_cuda": "11.6", + "neuralop_commit": "fbdc7f872792b75b84545c2f374e7a881c72a718", + "neuralop_file_sha256": { + "utils.py": "84554eed45ac415ab52f79e456eab70ba204e7ab7539c2f2841955a9145220b4", + "models/__init__.py": "c67679f1f8f90e1ab4eb4c2aa916aeaedf1b175d795fed03b8d4f7210883ebae", + "models/tfno.py": "d74b5805b69a64bf33e3ff5186709c75bd431a56c9548f06fb9635a859d849e4", + "models/spectral_convolution.py": "ccecf80806d93e8f35713ac6ab2c3b61c11739f5fcb8c0ba7397b7d4eb5a5d45" + }, + "package_versions": { + "torch": "1.13.1+cu116", + "open3d": "0.17.0", + "numpy": "1.24.3", + "torch-scatter": "2.1.1+pt113cu116", + "torch-sparse": "0.6.17+pt113cu116", + "torch-geometric": "2.3.1", + "tensorly": "0.8.1", + "tensorly-torch": "0.4.0" + } + }, + "compute_regime": "one V100, one serial process, no other GPU occupants", + "opens_only_original_paper_data": true, + "acceptance_interval_provenance": "team preregistered tolerance", + "exact_original_published_cli_overrides_known": false +} diff --git a/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/contract.json b/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/contract.json new file mode 100644 index 000000000..7d69bc749 --- /dev/null +++ b/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/contract.json @@ -0,0 +1,752 @@ +{ + "mode": "measurement", + "ruling": "h-f84547d7", + "retry": false, + "evaluate_other_models": false, + "measurement_allowed_heldout_labels": false, + "gpu_uuid": "GPU-f1c9fd5a-e917-56e0-21fb-24035ba44a36", + "limits": { + "gpu_wall_seconds": 3600, + "cleanup_seconds": 60, + "idle_wait_seconds": 60, + "cpu_seconds": 3500, + "rss_bytes": 12884901888, + "recorded_vram_bytes": 15032385536, + "device_vram_bytes": 16106127360, + "disk_bytes": 2147483648, + "torch_threads": 1, + "max_processes": 1 + }, + "protocol": { + "model": "NeurIPS 2023 supplement SDFFNOGNO decoder", + "seeds": [ + 0, + 1, + 2 + ], + "grid": [ + 64, + 64, + 64 + ], + "modes": [ + 24, + 24, + 24 + ], + "hidden_channels": 32, + "radius": 0.05, + "epochs_per_seed": 100, + "batch_size": 1, + "learning_rate": 0.001, + "bounds_expansion": 0.01, + "pressure_epsilon": 1e-06, + "optimizer": "Adam", + "weight_decay": 0.0001, + "lr_step_epochs": 50, + "lr_gamma": 0.5, + "pressure_training_transform": "scalar Gaussian on the 500 learning cases", + "metric": "per-case L2(predicted minus true decoded pressure) / L2(true decoded pressure)", + "report": "equal mean over 111 cases for each seed, then equal mean over the three seeds", + "acceptance_percent": [ + 6.62, + 7.62 + ], + "paper_reference_percent": 7.12, + "checkpoint_epoch": 100, + "heldout_access_after_all_checkpoints_frozen": true + }, + "environment": { + "python": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/runtime/bin/python", + "python_version": "3.10", + "torch_cuda": "11.6", + "neuralop_commit": "fbdc7f872792b75b84545c2f374e7a881c72a718", + "neuralop_file_sha256": { + "utils.py": "84554eed45ac415ab52f79e456eab70ba204e7ab7539c2f2841955a9145220b4", + "models/__init__.py": "c67679f1f8f90e1ab4eb4c2aa916aeaedf1b175d795fed03b8d4f7210883ebae", + "models/tfno.py": "d74b5805b69a64bf33e3ff5186709c75bd431a56c9548f06fb9635a859d849e4", + "models/spectral_convolution.py": "ccecf80806d93e8f35713ac6ab2c3b61c11739f5fcb8c0ba7397b7d4eb5a5d45" + }, + "package_versions": { + "torch": "1.13.1+cu116", + "open3d": "0.17.0", + "numpy": "1.24.3", + "torch-scatter": "2.1.1+pt113cu116", + "torch-sparse": "0.6.17+pt113cu116", + "torch-geometric": "2.3.1", + "tensorly": "0.8.1", + "tensorly-torch": "0.4.0" + } + }, + "comparison_contract": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/comparison-contract.json", + "comparison_contract_sha256": "503f6c8ab1217d66b44e0d127555cfad5da4cd8a17b336299095c3cfd13041d7", + "code_sha256": { + "/home/frank14f/optane/MeltMind/tools/freeze_g1_components.py": "d0cee60d95243ac2c59ef3f2244ba818315718c4e3d1895f2f9f064f1f7f5ecd", + "/home/frank14f/optane/MeltMind/tools/gre24_models.py": "53b6fee8b700b9b982b06d29908ce2ce23e0c57512c46dbf74b2aade79e3ac3a", + "/home/frank14f/optane/MeltMind/tools/phase2_gate_outcome_review.py": "915617aeb8292d03c654e637bc34a014c254fd178a773f135d1806c4b41372a8", + "/home/frank14f/optane/MeltMind/tools/phase2_h1_worker_v2.py": "1543df85b615bb69b79bacd572074a7c77ae19dab110197601573a7e5805ed20", + "/home/frank14f/optane/MeltMind/tools/phase2_home_freeze_io.py": "bf09204b85ed2a7038acdd202257f618474d1110a9d6d772f105a3ffb334d3ff", + "/home/frank14f/optane/MeltMind/tools/phase2_local_freeze_io.py": "60adf3382577613c5234f5cf30779336b9951b66e90c075cb7cd0adab9cc42dd", + "/home/frank14f/optane/MeltMind/tools/phase2_residual_math.py": "ffbd9624dec79bdaabf95244fe87209055908f31a977e73ea4377045d6f8fe62", + "/home/frank14f/optane/MeltMind/tools/phase3_item1b_common.py": "4e25effe8326ff8c7c3f751590315040209af054b32b0505dc3c6b001589db32", + "/home/frank14f/optane/MeltMind/tools/phase3_seed1_v2_common.py": "25ca6be14027369393bd3616209b08f30e25892cccca83300483c5a116e8d75d", + "/home/frank14f/optane/MeltMind/tools/phase3_shared_capacity.py": "7c07b0aaf1bc4e6a980d016defcac326c3bd871134d2583bb4dcd88bb34728f8", + "/home/frank14f/optane/MeltMind/tools/prepare_track_b_gino_shapenet.py": "557ad56277d7e85c6b5cc358eb151632d1757f5883f429988d36022d0d407550", + "/home/frank14f/optane/MeltMind/tools/s2_gpu_idle_gate.py": "e2b1613e7e6ea398a8d555220a9365a1ad998ab4ef4b2bf8ec7cc4e31f8b4b9f", + "/home/frank14f/optane/MeltMind/tools/s2_main_memory_guard.py": "e094f5443e11518efe9018215c11718a8e18aa462a977bf43e974b2d0b2aebb1", + "/home/frank14f/optane/MeltMind/tools/s2_pilot_train.py": "e9cceead51a5cc092aad23409ad98909c84a62e7e10571e750d1e9be1ad3b948", + "/home/frank14f/optane/MeltMind/tools/s2_precision_continuation_guard.py": "01235d897c7c03e5ffa109c58b14f5d24d128e8f1ba873e1f76cfb14e02f7a7f", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_gpu_supervisor.py": "689c0f3179e4fcd362e546d90214829a9e4f8739abdbdf74b560763e5a392f15", + "/home/frank14f/optane/MeltMind/tools/s2_recovery_monitoring.py": "442c2a9c75e8c00b30a8f2e91cb52d87c466b19a80aea9128b10c021e61b922e", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_common.py": "79918e7de887d1f0a2de5523156b27d00dc2d85ac930a07efc34d817d904fe65", + "/home/frank14f/optane/MeltMind/tools/track_a_h2_prepare.py": "f657be036dc48fc5936f56c4b8510a4b295d4787af6877cc5ccaad663107be17", + "/home/frank14f/optane/MeltMind/tools/track_b_gino_shapenet_entry.py": "e86d955c36e291e6bbef67947de663b24c8d66c5d72d9d28e4193fb8a3051ee2", + "/home/frank14f/optane/MeltMind/tools/track_b_gino_shapenet_worker.py": "7211be211c29472fd9be35a6bcb1f56025de4a63f36852bfafa10df97c003ff3" + }, + "paper_data": { + "path": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/paper-car-pressure-data.zip", + "sha256": "b5f9e2b407d54e034596384253fb58196933c46f6b5b586383508da54475f89d" + }, + "paper_supplement": { + "path": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/paper-neurips-supplement.zip", + "sha256": "48cdae80ac2781e27ac00e10a37124711d6bb305593559002bda0527d11a533d" + }, + "paper_code_zip_sha256": "347a6f097e2b9958d1ab87930fa1d6227b793a9d213e12418ce9a157e83dce04", + "split_receipt": { + "path": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-2026-11-19/paper-split.json", + "sha256": "5a96c25c2ec24cfc1e2264d4ebd0879c658c0f168e22711b576bf303151b8601" + }, + "mapping_audit": { + "path": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-2026-11-19/paper-mapping-audit.json", + "sha256": "055d008a02494acd29df36c41c8e68db931a027f5635e8f5f765a96a54c62289" + }, + "split": { + "train": [ + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 10, + 12, + 13, + 17, + 18, + 21, + 22, + 23, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 34, + 35, + 39, + 40, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 54, + 55, + 56, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 67, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 83, + 84, + 85, + 86, + 87, + 88, + 90, + 91, + 92, + 94, + 95, + 96, + 97, + 100, + 101, + 102, + 105, + 106, + 107, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 133, + 134, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 165, + 166, + 170, + 172, + 173, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 186, + 190, + 191, + 192, + 193, + 195, + 196, + 198, + 199, + 200, + 201, + 202, + 203, + 205, + 207, + 210, + 211, + 212, + 213, + 214, + 215, + 217, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 241, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 251, + 252, + 253, + 255, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 266, + 267, + 268, + 269, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 285, + 286, + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 304, + 305, + 306, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 327, + 328, + 329, + 331, + 332, + 333, + 334, + 335, + 337, + 338, + 339, + 340, + 341, + 344, + 345, + 347, + 348, + 349, + 350, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 360, + 362, + 364, + 365, + 366, + 367, + 369, + 371, + 372, + 373, + 374, + 375, + 376, + 378, + 379, + 380, + 381, + 384, + 385, + 389, + 392, + 393, + 397, + 398, + 399, + 401, + 402, + 403, + 404, + 405, + 407, + 408, + 410, + 412, + 413, + 414, + 415, + 417, + 418, + 419, + 420, + 422, + 424, + 425, + 427, + 430, + 431, + 433, + 435, + 436, + 437, + 439, + 440, + 443, + 444, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 459, + 460, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 472, + 473, + 474, + 475, + 476, + 478, + 479, + 480, + 482, + 483, + 486, + 487, + 488, + 490, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 501, + 502, + 503, + 504, + 505, + 507, + 508, + 509, + 511, + 512, + 513, + 514, + 515, + 516, + 518, + 519, + 521, + 522, + 523, + 524, + 525, + 527, + 529, + 530, + 532, + 533, + 536, + 538, + 539, + 540, + 542, + 543, + 545, + 547, + 548, + 549, + 550, + 551, + 552, + 553, + 554, + 555, + 560, + 561, + 562, + 564, + 565, + 566, + 567, + 568, + 569, + 572, + 573, + 574, + 576, + 577, + 579, + 581, + 582, + 583, + 584, + 587, + 588, + 589, + 591, + 593, + 594, + 595, + 596, + 597, + 598, + 600, + 602, + 604, + 608, + 610, + 611, + 612, + 613, + 615, + 616, + 617, + 618, + 620, + 621, + 622, + 623, + 625, + 626, + 627, + 628, + 629, + 630, + 631, + 632, + 633, + 634, + 635, + 636, + 638, + 639, + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647, + 648, + 649, + 651, + 652, + 654, + 655, + 656, + 657 + ], + "test": [ + 658, + 659, + 660, + 662, + 663, + 664, + 665, + 666, + 667, + 668, + 672, + 673, + 674, + 675, + 676, + 677, + 678, + 679, + 681, + 683, + 684, + 686, + 687, + 688, + 689, + 690, + 691, + 692, + 693, + 695, + 696, + 697, + 700, + 701, + 702, + 703, + 704, + 705, + 708, + 709, + 710, + 711, + 712, + 713, + 715, + 717, + 718, + 719, + 721, + 722, + 723, + 724, + 725, + 726, + 727, + 729, + 730, + 731, + 733, + 734, + 735, + 736, + 737, + 738, + 739, + 740, + 741, + 743, + 744, + 745, + 746, + 747, + 748, + 749, + 750, + 751, + 752, + 753, + 757, + 758, + 760, + 762, + 763, + 764, + 765, + 766, + 767, + 768, + 769, + 770, + 771, + 772, + 773, + 775, + 776, + 777, + 778, + 779, + 781, + 782, + 783, + 784, + 785, + 787, + 789, + 790, + 791, + 792, + 793, + 795, + 797 + ], + "raw_global_bounds": [ + [ + -0.90252799, + 0.0066688, + -2.85272002 + ], + [ + 0.90253001, + 1.95825005, + 2.86385012 + ] + ] + } +} diff --git a/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/measurement-gate.json b/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/measurement-gate.json new file mode 100644 index 000000000..991d4ea03 --- /dev/null +++ b/artifacts/track-b-gino-shapenet611-measurement-2026-11-19/measurement-gate.json @@ -0,0 +1,22 @@ +{ + "status": "NOT_AUTHORIZED_FOR_EXECUTION", + "candidate_contract_sha256": "139fec49b7e4627b55ad12f3a129bec75ecc2446811c23a24f376dae207094aa", + "runtime_installed_and_import_verified": false, + "measured_epoch_exists": false, + "requested_candidate_limit": { + "gpu_wall_seconds": 3600, + "cpu_seconds": 3500, + "device_count": 1 + }, + "requires": [ + "install and CPU import-verify the isolated pinned environment", + "Claude stage/budget authorization binding the measurement contract", + "independent exact PASS on the measurement contract and CPU mock receipt" + ], + "measurement": "one complete 500-case seed-0 training epoch plus preproc and a 111-case training-only forward proxy", + "heldout_labels_read": false, + "training_weights_reused": false, + "benchmark_contract_created": false, + "benchmark_cap_formula": "ceil(1.25*(prep_seconds+300*epoch_seconds+proxy_prep_seconds+3*proxy_inference_seconds)) + wait + cleanup", + "benchmark_requires": "fixed same-regime measurement receipts, new exact cap and separate review" +} diff --git a/docs/phase3-item1b-fold0-waiver-blocker-2026-11-19.md b/docs/phase3-item1b-fold0-waiver-blocker-2026-11-19.md new file mode 100644 index 000000000..ae377fe9f --- /dev/null +++ b/docs/phase3-item1b-fold0-waiver-blocker-2026-11-19.md @@ -0,0 +1,7 @@ +# Phase 3 1b 折 0|豁免采用核对 + +MeltAssist 对原 `ed6bfe11` 的独立 verdict 为 `BLOCKED`。两项原始发现及失败夹具均保留。第三次空闲观测在 59 秒返回,后续复查可推迟派发到 62 秒。本地模拟还复现总账 13,180.8 GPU 秒时入口仍返回 `COMPLETE`。等待预留 66 秒的另一候选已通过证据窄审,原件标注 `launch_ready=false`。[原绑定窄审](../artifacts/meltassist-item1b-fold0-final-deadline-review-2026-11-19/review.json) · [66 秒证据窄审](../artifacts/meltassist-item1b-wait-reserve-narrow-review-2026-11-19/review.json) + +Claude h-b951c2d8 仅豁免原绑定的上述两项。卡已确认空闲,额外复查降低派发风险。任务分段上限仍能防止成本失控,末段结算若超 13,180 GPU 秒须保留并报告实耗。该裁定适用本次原绑定。 + +原审阅回执的提交、合同、实现证明、比较合同和代码映射均逐项匹配。原入口在 `tools/phase3_item1b_fold0.py:360` 调用复核,`tools/phase2_gate_outcome_review.py:12` 只接受精确独立 `PASS`。用冻结文件及原 `BLOCKED` 回执送入该函数,实得 `Actual exact PASS required`。现有入口没有接收“原 verdict 加 Claude 豁免”的字段,采用受阻,启动记录及运行回执均未生成。[采用核对](../artifacts/phase3-item1b-fold0-waiver-blocker-2026-11-19/adoption-check.json) diff --git a/docs/track-b-gino-shapenet611-entry-2026-11-19.md b/docs/track-b-gino-shapenet611-entry-2026-11-19.md new file mode 100644 index 000000000..eb2777880 --- /dev/null +++ b/docs/track-b-gino-shapenet611-entry-2026-11-19.md @@ -0,0 +1,17 @@ +# Track B|GINO 复现入口与测量门 + +按 Claude h-f84547d7,数据源固定为已逐件核验的 NeurIPS 论文 SDF 原包。学习集为原清单前 500 件,独立评分集为后 111 件。[原档与协议证据](./track-b-gino-shapenet611-2026-11-19.md) + +## 复现口径 + +- 使用论文补充代码的 `SDFFNOGNO` decoder 和 64³ latent grid。直接导入论文类以补足附码工厂漏导入。其余采用附档候选参数,宽度 32、频模 24³、半径 0.05、batch 1、Adam 初始学习率 0.001,50 轮减半。第 100 轮是唯一采用的检查点。原表所用的全部命令行覆盖未发布。 +- 用 500 件学习数据拟合校正压力的标量高斯变换。独立运行种子 0、1、2,三组最终模型均冻结后才打开 111 件目标。逐件对反归一化压力计算相对 L2,再对每种子的 111 件等权平均。报告三个种子及其等权均值。均值须落在闭区间 **6.62%–7.62%**,这是针对论文 7.12% 事先登记的团队容差。 +- 固定 2023 年 NeuralOperator 提交 `fbdc7f8`,核过 FNO、Projection、FactorizedSpectralConv 与 UnitGaussianNormalizer 接口。孤立运行环境选 Python 3.10、Torch 1.13.1+cu116、Open3D 0.17.0 和对应 PyG 扩展。当前现有项目环境为 Torch 2.5.1,缺 Open3D 与旧版扩展。待安装后用入口的 `--check-environment` 做空 CUDA 可见性的导入验收。[NeuralOperator 固定源码](https://github.com/neuraloperator/neuraloperator/tree/fbdc7f872792b75b84545c2f374e7a881c72a718) · [PyTorch 官方轮包](https://docs.pytorch.org/get-started/previous-versions/#v1131) · [PyG 官方扩展索引](https://data.pyg.org/whl/torch-1.13.0+cu116.html) + +## 待审测量范围 + +现有材料中未找到同一 GINO 配置、同一串行 V100 并发度的实测轮时。待审候选限定一张 V100、一个进程、总计最多 3,600 GPU 秒。只计 seed 0 的一轮完整 500 件训练,以及用前 111 件学习样件测预处理和推理代理。记录训练预处理、完整轮时、代理预处理和推理耗时。测量权重不存为复现模型。 + +收到实际守卫终态后,用同卡同并发的实测耗时计算正式帽。一次训练预处理、300 个训练轮次、一次 111 件预处理代理和三次推理代理的时耗相加乘 1.25,再计等待、清理预留。测量和正式三种子入口各需绑定独立 PASS 与阶段授权,正式入口须引用原测量合同、终态和结果哈希。当前三种子实际预算待实测。 + +真实测量候选合同已经送入真实守卫做四类 CPU 模拟。空卡路径模拟一次派发,忙卡及最终复查越过 60 秒的路径均零派发,模拟实账 3,600.8 秒返回 `TOTAL_GPU_WALL_CAP`。以上均无科学数组读取和真实 worker。当前状态为等待环境验收及两类审阅,测量未开始。[比较合同](../artifacts/track-b-gino-shapenet611-measurement-2026-11-19/comparison-contract.json) · [测量门](../artifacts/track-b-gino-shapenet611-measurement-2026-11-19/measurement-gate.json) · [CPU 守卫回执](../artifacts/track-b-gino-shapenet611-measurement-2026-11-19/actual-guard-cpu-preflight.json) diff --git a/tools/prepare_track_b_gino_shapenet.py b/tools/prepare_track_b_gino_shapenet.py new file mode 100644 index 000000000..aa7b8f07a --- /dev/null +++ b/tools/prepare_track_b_gino_shapenet.py @@ -0,0 +1,182 @@ +"""Freeze the paper protocol and CPU-test the measurement dispatch contract.""" + +from functools import partial +from pathlib import Path +from tempfile import TemporaryDirectory +from types import SimpleNamespace +from unittest.mock import patch + +from phase2_h1_worker_v2 import checked, save, sha +from track_a_h2_prepare import local_code_closure +import track_b_gino_shapenet_entry as entry +from s2_gpu_idle_gate import wait_idle + + +BASE = entry.BASE +DATA = BASE / "data/track-b-gino-shapenet611-2026-11-19" +AUDIT = BASE / "artifacts/track-b-gino-shapenet611-2026-11-19" +UPSTREAM = Path("/tmp/meltmind-track-b-shapenet611-20261119") +NEURALOP = "fbdc7f872792b75b84545c2f374e7a881c72a718" +GPU = "GPU-f1c9fd5a-e917-56e0-21fb-24035ba44a36" + + +def prepare(): + root = entry.MEASUREMENT_ROOT + if root.exists(): + raise FileExistsError("The Track B measurement preparation already exists") + split_path = AUDIT / "paper-split.json" + split = entry.read(split_path) + mapping = AUDIT / "paper-mapping-audit.json" + audit = entry.read(mapping) + if (audit["status"] != "PAPER_ARCHIVE_SPLIT_AND_MAPPING_AUDITED" + or audit["manifest_sha256"] != split["manifest_sha256"] + or audit["global_bounds_sha256"] != split["raw_global_bounds_sha256"]): + raise ValueError("Paper data not verified") + for partition in ("train", "test"): + if [r["case"] for r in audit["rows"] if r["split"] == partition] != split[partition]: + raise ValueError("Audit sample order differs") + pressure = checked(DATA / "paper-car-pressure-data.zip", audit["archive_sha256"]) + supplement = checked(DATA / "paper-neurips-supplement.zip", split["paper_supplement_zip_sha256"]) + paper_code = split["paper_code_zip_sha256"] + pin_names = {"utils.py": "legacy-utils.py", + "models/__init__.py": "legacy-__init__.py", + "models/tfno.py": "legacy-tfno.py", + "models/spectral_convolution.py": "legacy-spectral_convolution.py"} + upstream_hashes = {key: sha(UPSTREAM / name) for key, name in pin_names.items()} + environment = dict( + python=str(BASE / "data/track-b-gino-shapenet611-2026-11-19/runtime/bin/python"), + python_version="3.10", torch_cuda="11.6", neuralop_commit=NEURALOP, neuralop_file_sha256=upstream_hashes, + package_versions={ + "torch": "1.13.1+cu116", "open3d": "0.17.0", "numpy": "1.24.3", + "torch-scatter": "2.1.1+pt113cu116", "torch-sparse": "0.6.17+pt113cu116", + "torch-geometric": "2.3.1", "tensorly": "0.8.1", "tensorly-torch": "0.4.0", + }) + protocol = dict( + model="NeurIPS 2023 supplement SDFFNOGNO decoder", seeds=[0, 1, 2], + grid=[64, 64, 64], modes=[24, 24, 24], hidden_channels=32, radius=.05, + epochs_per_seed=100, batch_size=1, learning_rate=.001, bounds_expansion=.01, + pressure_epsilon=1.e-6, optimizer="Adam", weight_decay=1.e-4, + lr_step_epochs=50, lr_gamma=.5, pressure_training_transform="scalar Gaussian on the 500 learning cases", + metric="per-case L2(predicted minus true decoded pressure) / L2(true decoded pressure)", + report="equal mean over 111 cases for each seed, then equal mean over the three seeds", + acceptance_percent=[6.62, 7.62], paper_reference_percent=7.12, + checkpoint_epoch=100, heldout_access_after_all_checkpoints_frozen=True) + root.mkdir(exist_ok=False) + comparison = root / "comparison-contract.json" + save(comparison, dict( + ruling=entry.RULING, protocol=protocol, paper_code_zip_sha256=paper_code, + source_protocol_commit="8d5c498e3be25580cf022890add6b32d7d6b8a93", + split_sha256=sha(split_path), audited_mapping_sha256=sha(mapping), + environment=environment, compute_regime="one V100, one serial process, no other GPU occupants", + opens_only_original_paper_data=True, acceptance_interval_provenance="team preregistered tolerance", + exact_original_published_cli_overrides_known=False)) + code_paths = [Path(__file__), Path(entry.__file__), BASE / "tools/track_b_gino_shapenet_worker.py"] + codes = local_code_closure(code_paths) + limit = dict(gpu_wall_seconds=3600, cleanup_seconds=60, idle_wait_seconds=60, cpu_seconds=3500, + rss_bytes=12 * 2**30, recorded_vram_bytes=14 * 2**30, device_vram_bytes=15 * 2**30, + disk_bytes=2 * 2**30, torch_threads=1, max_processes=1) + path = root / "contract.json" + def pin(p): + return dict(path=str(p), sha256=sha(p)) + + save(path, dict(mode="measurement", ruling=entry.RULING, retry=False, evaluate_other_models=False, + measurement_allowed_heldout_labels=False, gpu_uuid=GPU, limits=limit, + protocol=protocol, environment=environment, comparison_contract=str(comparison), + comparison_contract_sha256=sha(comparison), code_sha256=codes, + paper_data=pin(pressure), paper_supplement=pin(supplement), + paper_code_zip_sha256=paper_code, split_receipt=pin(split_path), mapping_audit=pin(mapping), + split={key: split[key] for key in ("train", "test", "raw_global_bounds")})) + save(root / "measurement-gate.json", dict( + status="NOT_AUTHORIZED_FOR_EXECUTION", candidate_contract_sha256=sha(path), + runtime_installed_and_import_verified=False, measured_epoch_exists=False, + requested_candidate_limit=dict(gpu_wall_seconds=3600, cpu_seconds=3500, device_count=1), + requires=["install and CPU import-verify the isolated pinned environment", + "Claude stage/budget authorization binding the measurement contract", + "independent exact PASS on the measurement contract and CPU mock receipt"], + measurement="one complete 500-case seed-0 training epoch plus preproc and a 111-case training-only forward proxy", + heldout_labels_read=False, training_weights_reused=False, + benchmark_contract_created=False, + benchmark_cap_formula="ceil(1.25*(prep_seconds+300*epoch_seconds+proxy_prep_seconds+3*proxy_inference_seconds)) + wait + cleanup", + benchmark_requires="fixed same-regime measurement receipts, new exact cap and separate review")) + return path + + +def preflight(path): + c = entry.contract(path) + gpu = c["gpu_uuid"] + clock = 0. + mock_cases = [] + for scenario in ("idle", "busy", "late_final_check", "total_cap"): + clock = 0. + polls = 0 + + def sleep(seconds): + nonlocal clock + clock += seconds + + def sample(uuid): + nonlocal polls + if uuid != gpu: + raise ValueError("Actual contract GPU identity lost") + polls += 1 + idle = scenario != "busy" + if scenario == "late_final_check": + early_busy = polls <= 3 + duration = 2. if early_busy else 1. if polls <= 6 else 3. + idle = not early_busy + sleep(duration) + elif scenario == "busy": + sleep(2.) + return dict(uuid=uuid, idle=idle, memory_MiB=5 if idle else 1600, occupants=[]) + + def worker(command, actual_root, name, limits, *, poll, gpu_uuid): + if (actual_root != root or name != "gino" or command[0] != c["environment"]["python"] + or Path(command[1]).name != "track_b_gino_shapenet_worker.py" or command[2:] != [str(root)] + or gpu_uuid != gpu or limits["total_cpu_seconds"] != c["limits"]["cpu_seconds"] + or limits["tree_rss_bytes"] != c["limits"]["rss_bytes"] + or limits["disk_bytes"] != c["limits"]["disk_bytes"] + or limits["max_processes"] != c["limits"]["max_processes"] + or not 0 < limits["job_wall_seconds"] < c["limits"]["gpu_wall_seconds"]): + raise ValueError("Modified fields at actual dispatch") + records = root / "worker-records" + records.mkdir() + save(records / "result.json", dict( + status="COMPLETE", mode="measurement", heldout_labels_read=False, epochs=1, + training_examples=500, proxy_examples=111, reuse_measurement_weights=False, + preparation_seconds=1., epoch_seconds=2., proxy_preparation_seconds=1., + proxy_inference_seconds=1., peak_allocated_bytes=100, peak_reserved_bytes=200)) + sleep(c["limits"]["gpu_wall_seconds"] - clock + .8 if scenario == "total_cap" else 2.) + return dict(status="PASS", returncode=0, monitor_errors=0) + + expected = { + "idle": ("COMPLETE", None, 1), + "busy": ("STOPPED", "IDLE_DEADLINE", 0), + "late_final_check": ("STOPPED", "IDLE_DEADLINE_AFTER_FINAL_CHECK", 0), + "total_cap": ("STOPPED", "TOTAL_GPU_WALL_CAP", 1), + }[scenario] + with TemporaryDirectory(prefix="track-b-gino-cpu-guard-") as scratch: + root = Path(scratch) + with (patch.object(entry, "snapshot", side_effect=sample), + patch.object(entry, "time", SimpleNamespace(monotonic=lambda: clock)), + patch.object(entry, "wait_idle", partial(wait_idle, clock=lambda: clock, sleep=sleep)), + patch.object(entry, "supervise", side_effect=worker) as dispatch): + code = entry.dispatch_guard(root, path) + terminal = entry.read(root / "complete.json") + if (terminal["status"], terminal["trigger"], dispatch.call_count) != expected: + raise RuntimeError(f"Actual guard differed for {scenario}: {terminal}") + if code != (0 if scenario == "idle" else 1): + raise RuntimeError("Terminal return code differs") + mock_cases.append(dict(scenario=scenario, synthetic_worker_dispatches=dispatch.call_count, + status=terminal["status"], trigger=terminal["trigger"], + booked_idle_seconds=terminal["booked_idle_seconds"], + charged_gpu_wall_seconds=terminal["cumulative_gpu_wall_seconds"])) + return dict(status="PASS", actual_contract_sha256=sha(path), cases=mock_cases, + real_gpu_queries=0, real_workers=0, scientific_arrays_read=False, + does_not_supply_measured_epoch_seconds=True) + + +if __name__ == "__main__": + path = prepare() + proof = preflight(path) + save(path.parent / "actual-guard-cpu-preflight.json", proof) + print(proof) diff --git a/tools/track_b_gino_shapenet_entry.py b/tools/track_b_gino_shapenet_entry.py new file mode 100644 index 000000000..092d6edd9 --- /dev/null +++ b/tools/track_b_gino_shapenet_entry.py @@ -0,0 +1,262 @@ +"""Review-gated dispatch for the original ShapeNet GINO reproduction.""" + +import argparse +import ctypes +import fcntl +import math +import os +from pathlib import Path +import shutil +import signal +import threading +import time + +from phase2_gate_outcome_review import validate_review +from phase2_h1_worker_v2 import checked, save, sha +from phase3_item1b_common import read +from phase3_shared_capacity import process_identity +from s2_gpu_idle_gate import snapshot, wait_idle +from s2_main_memory_guard import PeakRecords, active_command_pids +from s2_recovery_gpu_supervisor import stop_group, supervise + + +BASE = Path(__file__).resolve().parents[1] +MEASUREMENT_ROOT = BASE / "artifacts/track-b-gino-shapenet611-measurement-2026-11-19" +BENCHMARK_ROOT = BASE / "artifacts/track-b-gino-shapenet611-benchmark-2026-11-19" +RULING = "h-f84547d7" + + +def projected_budget(measurement, limits): + prep = measurement["preparation_seconds"] + train = measurement["epoch_seconds"] + test_prep = measurement["proxy_preparation_seconds"] + inference = measurement["proxy_inference_seconds"] + if any(not math.isfinite(x) or x <= 0 for x in (prep, train, test_prep, inference)): + raise ValueError("Incomplete empirical timing components") + if (measurement["epochs"], measurement["training_examples"], measurement["proxy_examples"], + measurement["heldout_labels_read"], measurement["reuse_measurement_weights"]) != (1, 500, 111, False, False): + raise ValueError("Timing does not represent the reviewed learning-only measurement") + # One serial worker, one preprocessing pass per domain, and three fresh + # serial 100-epoch fits. The fixed wait and cleanup are charged separately. + return math.ceil(1.25 * (prep + 3 * 100 * train + test_prep + 3 * inference)) + ( + limits["idle_wait_seconds"] + limits["cleanup_seconds"]) + + +def contract(path): + c = read(path) + if c["ruling"] != RULING or c["mode"] not in ("measurement", "benchmark"): + raise PermissionError("Only the paper GINO execution scope is supported") + if c["retry"] is not False or c["evaluate_other_models"] is not False: + raise PermissionError("Single reviewed GINO attempt required") + for path, digest in c["code_sha256"].items(): + checked(path, digest) + sources = ("paper_data", "paper_supplement", "split_receipt", "mapping_audit") + for name in sources: + pin = c[name] + checked(pin["path"], pin["sha256"]) + comparison = read(checked(c["comparison_contract"], c["comparison_contract_sha256"])) + if c["protocol"] != comparison["protocol"]: + raise ValueError("Model/score protocol differs from the comparison contract") + split = c["split"] + original = read(c["split_receipt"]["path"]) + if any(split[key] != original[key] for key in ("train", "test", "raw_global_bounds")): + raise ValueError("Original ShapeNet split or bounds changed") + if len(set(split["train"])) != 500 or len(set(split["test"])) != 111 or set(split["train"]) & set(split["test"]): + raise ValueError("Expected disjoint original 500/111 split") + p = c["protocol"] + if p["grid"] != [64, 64, 64] or p["epochs_per_seed"] != 100 or p["seeds"] != [0, 1, 2]: + raise ValueError("Fixed decoder resolution, epochs or seeds changed") + if p["acceptance_percent"] != [6.62, 7.62]: + raise ValueError("Original pre-registered team interval changed") + limit = c["limits"] + caps = ("gpu_wall_seconds", "cleanup_seconds", "idle_wait_seconds", "cpu_seconds", "rss_bytes", + "recorded_vram_bytes", "device_vram_bytes", "disk_bytes", "torch_threads", "max_processes") + if any(type(limit[k]) is not int or limit[k] <= 0 for k in caps): + raise ValueError("All runtime limits must be positive integers") + if limit["idle_wait_seconds"] + limit["cleanup_seconds"] >= limit["gpu_wall_seconds"]: + raise ValueError("No runtime after booking admission and cleanup") + if c["mode"] == "measurement": + if c["measurement_allowed_heldout_labels"] is not False: + raise PermissionError("Measurement may only use the learning split") + else: + timed = c["measured_timing"] + expected_paths = { + "path": MEASUREMENT_ROOT / "worker-records/result.json", + "guard_path": MEASUREMENT_ROOT / "complete.json", + "contract_path": MEASUREMENT_ROOT / "contract.json", + } + if any(Path(timed[key]).resolve() != expected for key, expected in expected_paths.items()): + raise ValueError("Timing must come from the sole reviewed measurement root") + timing = read(checked(timed["path"], timed["sha256"])) + witness = read(checked(timed["guard_path"], timed["guard_sha256"])) + if (witness["status"] != "COMPLETE" or witness["contract_sha256"] != timed["contract_sha256"] + or witness["result_sha256"] != timed["sha256"] or timing["mode"] != "measurement" + or timing["status"] != "COMPLETE"): + raise ValueError("Benchmark requires the authentic measured timing and guard result") + measured = contract(Path(checked(timed["contract_path"], timed["contract_sha256"]))) + for key in ("gpu_uuid", "paper_data", "paper_code_zip_sha256", "comparison_contract_sha256", "environment"): + if measured[key] != c[key]: + raise ValueError(f"Timing and benchmark execution regime differs: {key}") + if measured["mode"] != "measurement" or measured["limits"]["torch_threads"] != limit["torch_threads"]: + raise ValueError("Timing is not from the same worker/CPU configuration") + validate_review(MEASUREMENT_ROOT) + if limit["gpu_wall_seconds"] != projected_budget(timing, limit): + raise ValueError("Benchmark cap must come from the measured +25% projection") + return c + + +def dispatch_guard(root, contract_path): + started = time.monotonic() + c = contract(contract_path) + cap = c["limits"] + deadline = started + cap["gpu_wall_seconds"] + wait_deadline = started + cap["idle_wait_seconds"] + gpu = c["gpu_uuid"] + status, reason = "STOPPED", None + receipt = None + waiting = 0. + output = None + tracker = PeakRecords() + command = [c["environment"]["python"], str(Path(__file__).with_name("track_b_gino_shapenet_worker.py")), str(root)] + try: + if shutil.disk_usage(root).free < cap["disk_bytes"]: + raise RuntimeError("DISK_HEADROOM") + # Use the shared poller, then look at wall time again after the last + # independent check and the dispatch receipt write. + begin_wait = time.monotonic() + remaining_window = max(0., wait_deadline - begin_wait) + idle = wait_idle(gpu, remaining_window, lambda _: None, sample=snapshot) + waiting = time.monotonic() - begin_wait + save(root / "idle-gate.json", idle) + if idle["status"] != "IDLE_CONFIRMED" or time.monotonic() >= wait_deadline: + raise RuntimeError("IDLE_DEADLINE") + if not snapshot(gpu)["idle"]: + raise RuntimeError("SELECTED_GPU_BECAME_BUSY") + save(root / "dispatch.json", dict(contract_sha256=sha(contract_path), + coordinator=process_identity(os.getpid()), + start_by_monotonic=wait_deadline)) + now = time.monotonic() + waiting = now - begin_wait + if now >= wait_deadline: + raise RuntimeError("IDLE_DEADLINE_AFTER_FINAL_CHECK") + remaining = deadline - now - cap["cleanup_seconds"] + if remaining <= 0: + raise RuntimeError("INSUFFICIENT_REMAINING_BUDGET") + reasons = [] + done = threading.Event() + + def monitor(): + while not done.is_set(): + try: + tracker.scan(root / "worker-records") + state = snapshot(gpu) + allowed = set(active_command_pids(command)) + if max(tracker.maxima.values()) > cap["recorded_vram_bytes"]: + reasons.append("RECORDED_VRAM_LIMIT") + if state["memory_MiB"] * 2**20 > cap["device_vram_bytes"]: + reasons.append("DEVICE_VRAM_LIMIT") + if any(p["pid"] not in allowed for p in state["occupants"]): + reasons.append("FOREIGN_GPU_OCCUPANT") + except Exception as exc: + reasons.append("MONITOR_FAILURE: " + str(exc)) + if reasons: + for pid in active_command_pids(command): + stop_group(pid) + done.wait(.5) + + watcher = threading.Thread(target=monitor, daemon=True) + watcher.start() + try: + receipt = supervise(command, root, "gino", dict( + total_cpu_seconds=cap["cpu_seconds"], job_cpu_seconds=cap["cpu_seconds"], + job_wall_seconds=remaining, tree_rss_bytes=cap["rss_bytes"], + disk_bytes=cap["disk_bytes"], max_processes=cap["max_processes"]), poll=.2, gpu_uuid=gpu) + finally: + done.set() + watcher.join(timeout=8) + if watcher.is_alive(): + raise RuntimeError("MONITOR_DID_NOT_EXIT") + tracker.scan(root / "worker-records") + if max(tracker.maxima.values()) > cap["recorded_vram_bytes"]: + reasons.append("RECORDED_VRAM_LIMIT") + if reasons or receipt["status"] != "PASS" or receipt["returncode"] != 0 or receipt["monitor_errors"] != 0: + raise RuntimeError(reasons[0] if reasons else receipt.get("stop_reason") or "WORKER_FAILED") + output = root / "worker-records/result.json" + result = read(output) + if (result["status"] != "COMPLETE" or result["mode"] != c["mode"] + or set(tracker.witnesses) != set(tracker.maxima)): + raise RuntimeError("INCOMPLETE_WORKER_RESULT") + if c["mode"] == "measurement" and (result["heldout_labels_read"] or result["epochs"] != 1): + raise RuntimeError("MEASUREMENT_SCOPE_MISMATCH") + if c["mode"] == "benchmark" and (not result["heldout_labels_read"] + or set(result["seeds"]) != {str(x) for x in c["protocol"]["seeds"]} + or any([item["case"] for item in seed["cases"]] != c["split"]["test"] for seed in result["seeds"].values())): + raise RuntimeError("BENCHMARK_SUPPORT_MISMATCH") + status = "COMPLETE" + except (Exception, KeyboardInterrupt) as exc: + reason = str(exc) or type(exc).__name__ + result_hash = sha(output) if output is not None and output.is_file() else None + contract_hash = sha(contract_path) + measured = time.monotonic() - started + if measured > cap["gpu_wall_seconds"]: + status, reason = "STOPPED", "TOTAL_GPU_WALL_CAP" + save(root / "complete.json", dict( + status=status, trigger=reason, contract_sha256=contract_hash, result_sha256=result_hash, + worker=receipt, booked_idle_seconds=waiting, cumulative_gpu_wall_seconds=measured, + gpu_wall_cap_seconds=cap["gpu_wall_seconds"], recorded_peaks=tracker.maxima, no_retry=True)) + return 0 if status == "COMPLETE" else 1 + + +def authorized_child(root): + root = Path(root).resolve() + if root not in (MEASUREMENT_ROOT, BENCHMARK_ROOT): + raise PermissionError("Unrecognized Track B run root") + ticket = read(root / "dispatch.json") + parent = os.getppid() + if (ticket["coordinator"] != process_identity(parent) + or ticket["contract_sha256"] != sha(root / "contract.json") + or time.monotonic() >= ticket["start_by_monotonic"]): + raise PermissionError("Child is not attached to this reviewed guard") + if ctypes.CDLL(None, use_errno=True).prctl(1, signal.SIGKILL, 0, 0, 0) != 0 or os.getppid() != parent: + raise RuntimeError("Could not attach child lifetime to its coordinator") + validate_review(root) + return contract(root / "contract.json") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("root", type=Path) + args = parser.parse_args() + root = args.root.resolve() + if root not in (MEASUREMENT_ROOT, BENCHMARK_ROOT): + raise PermissionError("Unrecognized Track B run root") + validate_review(root) + path = root / "contract.json" + c = contract(path) + if (root == MEASUREMENT_ROOT) != (c["mode"] == "measurement"): + raise PermissionError("Execution root is tied to its reviewed stage") + # Separate authority for the costed measurement or benchmark. + authorization = read(root / "stage-authorization.json") + if (authorization["contract_sha256"] != sha(path) + or authorization["decision"] != "APPROVED" + or authorization["mode"] != c["mode"]): + raise PermissionError("Exact stage authorization is required") + if not os.access(c["environment"]["python"], os.X_OK): + raise FileNotFoundError("The isolated pinned GINO runtime is not available") + with (root / "entry.lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + if (root / "started.json").exists(): + raise FileExistsError("One attempt already recorded") + save(root / "started.json", dict(coordinator=process_identity(os.getpid()), contract_sha256=sha(path))) + def request_stop(signum, _frame): + raise KeyboardInterrupt(signal.Signals(signum).name) + + handler = signal.signal(signal.SIGTERM, request_stop) + try: + return dispatch_guard(root, path) + finally: + signal.signal(signal.SIGTERM, handler) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/track_b_gino_shapenet_worker.py b/tools/track_b_gino_shapenet_worker.py new file mode 100644 index 000000000..dcd0fff51 --- /dev/null +++ b/tools/track_b_gino_shapenet_worker.py @@ -0,0 +1,315 @@ +"""Paper GINO-decoder worker with a measurement-only stage and held-out scoring.""" + +import argparse +import io +import json +import math +import os +from pathlib import Path, PurePosixPath +import sys +from tempfile import TemporaryDirectory +import time +from zipfile import ZipFile + +from track_b_gino_shapenet_entry import authorized_child, checked, save, sha + + +def extract_paper_code(c, directory): + with ZipFile(c["paper_supplement"]["path"]) as outer: + archive = outer.read("GINO-supp/code.zip") + import hashlib + if hashlib.sha256(archive).hexdigest() != c["paper_code_zip_sha256"]: + raise ValueError("NeurIPS code archive identity mismatch") + directory = Path(directory) + with ZipFile(io.BytesIO(archive)) as code: + for member in code.infolist(): + path = PurePosixPath(member.filename) + if path.is_absolute() or ".." in path.parts: + raise ValueError("Invalid archive member path") + if not member.is_dir() and len(path.parts) >= 3 and path.parts[:2] == ("GINO-submission", "src"): + if path.suffix == ".py": + output = directory.joinpath(*path.parts[1:]) + output.parent.mkdir(parents=True, exist_ok=True) + with output.open("xb") as f: + f.write(code.read(member)) + sys.path.insert(0, str(directory)) + + +class OriginalData: + def __init__(self, c, workspace): + import numpy as np + import torch + from src.data.cfd_datamodule import CFDSDFDataModule, DictDatasetWithConstant + from neuralop.utils import UnitGaussianNormalizer + + self.np = np + self.torch = torch + self.dataset_class = DictDatasetWithConstant + self.normalizer_class = UnitGaussianNormalizer + self.c = c + self.workspace = Path(workspace) + self.paper = object.__new__(CFDSDFDataModule) + self.rows = {r["case"]: r for r in json.loads(Path(c["mapping_audit"]["path"]).read_bytes())["rows"]} + self.train_ids = c["split"]["train"] + self.test_ids = c["split"]["test"] + resolution = c["protocol"]["grid"] + raw_bounds = c["split"]["raw_global_bounds"] + epsilon = c["protocol"]["bounds_expansion"] + # Identical physical grid and coordinate transforms to the attached loader. + lo = [v - epsilon for v in raw_bounds[0]] + hi = [v + epsilon for v in raw_bounds[1]] + axis = [np.linspace(a, b, n) for a, b, n in zip(lo, hi, resolution)] + self.xyz = np.stack(np.meshgrid(*axis, indexing="ij"), axis=-1).astype(np.float32) + self.bounds = torch.tensor(lo), torch.tensor(hi) + self.grid = self.paper.location_normalization( + torch.from_numpy(self.xyz), *self.bounds).permute(3, 0, 1, 2) + self.normalizer = None + + def data(self, ids, role, target_log=None): + import hashlib + + if role == "train": + if ids != self.train_ids or self.normalizer is not None: + raise PermissionError("Only first-pass training normalization") + elif role == "train_proxy": + if ids != self.train_ids[:111] or self.normalizer is None: + raise PermissionError("Only the fixed learning-only timing proxy") + elif role == "heldout": + if ids != self.test_ids or target_log is None or self.normalizer is None: + raise PermissionError("Held-out arrays require a completed checkpoint freeze") + else: + raise PermissionError("Unexpected data role") + torch = self.torch + folder = self.workspace / role + folder.mkdir(exist_ok=False) + sdfs, vertices, pressures = [], [], [] + with ZipFile(self.c["paper_data"]["path"]) as archive: + for case in ids: + row = self.rows[case] + mesh = archive.read(f"car-pressure-data/data/mesh_{case:03d}.ply") + if hashlib.sha256(mesh).hexdigest() != row["mesh_sha256"]: + raise ValueError(f"Mesh hash mismatch: {case}") + path = folder / f"mesh_{case:03d}.ply" + path.write_bytes(mesh) + sdf, xyz, _ = self.paper.sdf_vertices_closest_from_mesh(path, self.xyz, False) + path.unlink() + if len(xyz) != row["mesh_vertices"] or sdf.shape != tuple(self.c["protocol"]["grid"]): + raise ValueError(f"Unexpected geometry dimensions: {case}") + sdfs.append(torch.as_tensor(sdf, dtype=torch.float32)) + vertices.append(self.paper.location_normalization( + torch.as_tensor(xyz, dtype=torch.float32), *self.bounds)) + if role == "heldout": + target_log.write(json.dumps(dict(case=case, role=role, sha256=row["pressure_sha256"])) + "\n") + target_log.flush() + pressure = archive.read(f"car-pressure-data/data/press_{case:03d}.npy") + if hashlib.sha256(pressure).hexdigest() != row["pressure_sha256"]: + raise ValueError(f"Pressure hash mismatch: {case}") + raw = self.np.load(io.BytesIO(pressure), allow_pickle=False).reshape(-1).astype(self.np.float32) + retained = self.np.concatenate((raw[:16], raw[112:])) + if len(retained) != len(xyz) or not self.np.isfinite(retained).all(): + raise ValueError(f"Pressure mapping mismatch: {case}") + pressures.append(torch.from_numpy(retained)) + p = torch.stack(pressures) + if role == "train": + self.normalizer = self.normalizer_class( + p, eps=self.c["protocol"]["pressure_epsilon"], reduce_dim=[0, 1], verbose=False) + p = self.normalizer.encode(p) + return self.dataset_class( + {"sdf": torch.stack(sdfs), "vertices": torch.stack(vertices), "pressure": p}, + {"sdf_query_points": self.grid}) + + +def paper_model(c): + # Use the same factory call schema as the paper. The attached factory is + # missing this symbol import, so the class is imported directly. + from src.networks.SDFFNOGNO import SDFFNOGNO + + p = c["protocol"] + return SDFFNOGNO(n_modes=p["modes"], hidden_channels=p["hidden_channels"], + norm="group_norm", use_mlp=True, mlp={"expansion": 1., "dropout": 0.}, + domain_padding=.125, factorization="tucker", rank=.4, out_channels=1, + r=p["radius"], resolution=p["grid"], gno_implementation="torch_scatter") + + +def cuda_peaks(torch): + return dict(peak_allocated_bytes=torch.cuda.max_memory_allocated(), + peak_reserved_bytes=torch.cuda.max_memory_reserved()) + + +def train_seed(c, dataset, seed, epochs, progress): + import numpy as np + import torch + from src.losses import LpLoss + + torch.manual_seed(seed) + np.random.seed(seed) + torch.cuda.manual_seed(seed) + torch.backends.cudnn.deterministic = True + model = paper_model(c).to("cuda") + optimizer = torch.optim.Adam(model.parameters(), lr=c["protocol"]["learning_rate"], weight_decay=1e-4) + scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=.5) + loss_fn = LpLoss(size_average=True) + loader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=True, num_workers=0) + times = [] + for epoch in range(1, epochs + 1): + model.train() + began = time.monotonic() + examples = 0 + for item in loader: + optimizer.zero_grad() + loss = model.loss_dict(item, loss_fn=loss_fn)["loss"].mean() + if not bool(torch.isfinite(loss)): + raise ValueError("Nonfinite training loss") + loss.backward() + optimizer.step() + examples += 1 + scheduler.step() + torch.cuda.synchronize() + if examples != 500: + raise ValueError("Incomplete full training epoch") + seconds = time.monotonic() - began + times.append(seconds) + save(progress, dict(stage="EPOCH_COMPLETE", seed=seed, epoch=epoch, examples=examples, + seconds=seconds, **cuda_peaks(torch))) + return model, times + + +def case_scores(model, data, cases, normalizer): + import torch + + loader = torch.utils.data.DataLoader(data, batch_size=1, shuffle=False, num_workers=0) + model.eval() + normalizer.to("cuda") + rows = [] + with torch.no_grad(): + for case, item in zip(cases, loader): + raw_input, output_vertices = model.data_dict_to_input(item) + prediction = normalizer.decode(model(raw_input, output_vertices)).reshape(-1) + truth = normalizer.decode(item["pressure"].to("cuda")).reshape(-1) + if prediction.numel() != 3586 or prediction.shape != truth.shape: + raise ValueError(f"Incomplete pressure vector: {case}") + denominator = torch.linalg.vector_norm(truth) + value = (torch.linalg.vector_norm(prediction - truth) / denominator).item() + if not math.isfinite(value) or denominator.item() <= 0: + raise ValueError(f"Undefined decoded relative L2: {case}") + rows.append(dict(case=case, relative_l2=value)) + normalizer.to("cpu") + if len(rows) != len(cases): + raise ValueError("Incomplete case coverage") + return rows + + +def test_environment(c): + import importlib.metadata + import importlib.util + import platform + + if ".".join(platform.python_version_tuple()[:2]) != c["environment"]["python_version"]: + raise RuntimeError("Pinned Python minor release required") + + for name, expected in c["environment"]["package_versions"].items(): + if importlib.metadata.version(name) != expected: + raise RuntimeError(f"Runtime distribution mismatch: {name}") + direct_url = importlib.metadata.distribution("neuraloperator").read_text("direct_url.json") + if not direct_url or json.loads(direct_url).get("vcs_info", {}).get("commit_id") != c["environment"]["neuralop_commit"]: + raise RuntimeError("Historical NeuralOperator commit not installed from its reviewed VCS pin") + module = importlib.util.find_spec("neuralop") + if module is None or module.origin is None: + raise RuntimeError("Historical NeuralOperator import missing") + root = Path(module.origin).parent + for relative, digest in c["environment"]["neuralop_file_sha256"].items(): + checked(root / relative, digest) + + +def work(root, c): + began = time.monotonic() + test_environment(c) + import torch + + if (os.environ.get("CUDA_VISIBLE_DEVICES") != c["gpu_uuid"] + or torch.version.cuda != c["environment"]["torch_cuda"]): + raise PermissionError("Runtime CUDA binding mismatch") + torch.set_num_threads(c["limits"]["torch_threads"]) + torch.set_num_interop_threads(1) + torch.cuda.set_device(0) + if "V100" not in torch.cuda.get_device_name(0): + raise ValueError("Selected device is not the fixed V100") + torch.cuda.reset_peak_memory_stats() + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + records = root / "worker-records" + records.mkdir(exist_ok=False) + with TemporaryDirectory(prefix="original-gino-", dir=root) as scratch: + extract_paper_code(c, scratch) + data = OriginalData(c, scratch) + train = data.data(data.train_ids, "train") + preparation_seconds = time.monotonic() - began + if c["mode"] == "measurement": + model, epoch_times = train_seed(c, train, c["protocol"]["seeds"][0], 1, records / "progress.json") + began_proxy = time.monotonic() + ids = data.train_ids[:111] + proxy = data.data(ids, "train_proxy") + proxy_preparation_seconds = time.monotonic() - began_proxy + began_eval = time.monotonic() + case_scores(model, proxy, ids, data.normalizer) + torch.cuda.synchronize() + result = dict(status="COMPLETE", mode="measurement", epochs=1, training_examples=500, + heldout_labels_read=False, proxy_examples=111, + preparation_seconds=preparation_seconds, epoch_seconds=epoch_times[0], + proxy_preparation_seconds=proxy_preparation_seconds, + proxy_inference_seconds=time.monotonic() - began_eval, + reuse_measurement_weights=False, **cuda_peaks(torch)) + else: + checkpoints = {} + for seed in c["protocol"]["seeds"]: + model, _ = train_seed(c, train, seed, 100, records / "progress.json") + file = root / f"seed-{seed}-epoch-100.pt" + torch.save(model.state_dict(), file) + checkpoints[str(seed)] = dict(path=str(file), sha256=sha(file)) + del model + predictions = root / "checkpoints-frozen.json" + save(predictions, checkpoints) + freeze_hash = sha(predictions) + checkpoints = json.loads(checked(predictions, freeze_hash).read_bytes()) + for item in checkpoints.values(): + checked(item["path"], item["sha256"]) + del train + with (root / "heldout-target-access.jsonl").open("x") as log: + heldout = data.data(data.test_ids, "heldout", log) + rows = {} + for seed, item in checkpoints.items(): + model = paper_model(c).to("cuda") + model.load_state_dict(torch.load(checked(item["path"], item["sha256"]), + map_location="cpu"), strict=True) + scores = case_scores(model, heldout, data.test_ids, data.normalizer) + rows[seed] = dict(cases=scores, mean_percent=100 * math.fsum(x["relative_l2"] for x in scores) / len(scores)) + del model + mean = math.fsum(seed["mean_percent"] for seed in rows.values()) / len(rows) + lower, upper = c["protocol"]["acceptance_percent"] + result = dict(status="COMPLETE", mode="benchmark", seeds=rows, mean_percent=mean, + within_registered_range=lower <= mean <= upper, + heldout_labels_read=True, split_sha256=c["split_receipt"]["sha256"], + checkpoints_manifest_sha256=freeze_hash, **cuda_peaks(torch)) + save(records / "result.json", result) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("root", type=Path) + parser.add_argument("--check-environment", action="store_true") + arg = parser.parse_args() + if arg.check_environment: + if os.environ.get("CUDA_VISIBLE_DEVICES") != "": + raise PermissionError("Set CUDA_VISIBLE_DEVICES empty for the isolated import check") + from track_b_gino_shapenet_entry import contract + c = contract(arg.root / "contract.json") + test_environment(c) + with TemporaryDirectory(prefix="track-b-gino-import-") as directory: + extract_paper_code(c, directory) + from src.data.cfd_datamodule import CFDSDFDataModule + from src.networks.SDFFNOGNO import SDFFNOGNO + print(json.dumps(dict(status="PASS", imports=[CFDSDFDataModule.__name__, SDFFNOGNO.__name__], + models_created=False, arrays_loaded=False))) + else: + c = authorized_child(arg.root) + work(arg.root, c)