Add current-policy star checks without campaign progression

BINARY_PROVENANCE.json

@@ -1 +1 @@
-{"artifact_origins":{"bin/altd-sim":{"build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","bytes":3580296,"origin_type":"local_linux_build","patch_sha256":"56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63","sha256":"6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d","source_receipt_sha256":"33d09c326e4d6c3ac1d1839e4528c70c06b4ff48138b90f174f434ab685b4b34","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"},"bin/extract_saved_track":{"build_receipt_path":"IMPORTER_BUILD_RECEIPT.json","build_receipt_sha256":"4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d","bytes":3247776,"compatibility_receipt_path":"native/build-receipt.json","compatibility_receipt_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","evidence_path":"IMPORTER_BUILD_RECEIPT.json","evidence_sha256":"4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d","origin_type":"retained_verified_importer_binary","sha256":"3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a","source_repository":"https://github.com/Zorro909/driving_sim_rs","source_revision":"d8ab74c25df70b6a86ed101080e33d5fb785ea6f"},"bin/libaltd_gpu.so":{"build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","bytes":4711704,"origin_type":"retained_cuda_b90","patch_sha256":"56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63","sha256":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca","source_receipt_sha256":"33d09c326e4d6c3ac1d1839e4528c70c06b4ff48138b90f174f434ab685b4b34","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"}},"artifacts":{"bin/altd-sim":{"bytes":3580296,"sha256":"6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d"},"bin/extract_saved_track":{"bytes":3247776,"sha256":"3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a"},"bin/libaltd_gpu.so":{"bytes":4711704,"sha256":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca"}},"build_receipt":"native/build-receipt.json","build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","importer_source_revision":"d8ab74c25df70b6a86ed101080e33d5fb785ea6f","native_patch_sha256":"56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63","note":"The simulator is a fresh Linux build from b90 plus the hashed local analysis patch. The CUDA library is retained b90 and has layout ABI evidence only; this package does not claim local GPU kernel execution. The track importer remains separately identified with bounded compatibility evidence.","source_repository":"https://github.com/Zorro909/driving_sim_rs","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"}
+{"artifact_origins":{"bin/altd-sim":{"build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"559a7e4e382f9f7caa1c5ceb566a5a0bbefad2ed3a2e2cf604e31c9c3890c348","bytes":3604272,"origin_type":"local_linux_build","patch_sha256":"42f79de67cb0734cffb2a7582f5479cab42ab82675884b8b42b9f158d46a98e8","sha256":"3aa1d364e0117f553a52404ae336efcfebd827fc0ca347e811196cbe31e32849","source_receipt_sha256":"36feba861501baf8672884476bbeed5e375254cbb4feffb9f4f90aa61a415a93","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"},"bin/extract_saved_track":{"build_receipt_path":"IMPORTER_BUILD_RECEIPT.json","build_receipt_sha256":"4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d","bytes":3247776,"compatibility_receipt_path":"native/build-receipt.json","compatibility_receipt_sha256":"559a7e4e382f9f7caa1c5ceb566a5a0bbefad2ed3a2e2cf604e31c9c3890c348","evidence_path":"IMPORTER_BUILD_RECEIPT.json","evidence_sha256":"4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d","origin_type":"retained_verified_importer_binary","sha256":"3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a","source_repository":"https://github.com/Zorro909/driving_sim_rs","source_revision":"d8ab74c25df70b6a86ed101080e33d5fb785ea6f"},"bin/libaltd_gpu.so":{"build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"559a7e4e382f9f7caa1c5ceb566a5a0bbefad2ed3a2e2cf604e31c9c3890c348","bytes":4711704,"origin_type":"retained_cuda_b90","patch_sha256":"42f79de67cb0734cffb2a7582f5479cab42ab82675884b8b42b9f158d46a98e8","sha256":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca","source_receipt_sha256":"36feba861501baf8672884476bbeed5e375254cbb4feffb9f4f90aa61a415a93","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"}},"artifacts":{"bin/altd-sim":{"bytes":3604272,"sha256":"3aa1d364e0117f553a52404ae336efcfebd827fc0ca347e811196cbe31e32849"},"bin/extract_saved_track":{"bytes":3247776,"sha256":"3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a"},"bin/libaltd_gpu.so":{"bytes":4711704,"sha256":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca"}},"build_receipt":"native/build-receipt.json","build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"559a7e4e382f9f7caa1c5ceb566a5a0bbefad2ed3a2e2cf604e31c9c3890c348","importer_source_revision":"d8ab74c25df70b6a86ed101080e33d5fb785ea6f","native_patch_sha256":"42f79de67cb0734cffb2a7582f5479cab42ab82675884b8b42b9f158d46a98e8","note":"The simulator is a fresh Linux build from b90 plus the hashed local analysis patch. The CUDA library is retained b90 and has layout ABI evidence only; this package does not claim local GPU kernel execution. The track importer remains separately identified with bounded compatibility evidence.","source_repository":"https://github.com/Zorro909/driving_sim_rs","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"}

FRONTEND_SOURCE.json

@@ -1 +1 @@
-{"base_provenance":{"output_sha256":"a145fbb303a85c728a530d98fbea998677c1c62a2589c46af9b8b287e4ce1f48","scope":"Frontend only; no engine, private data, track assets, API calls or storage copied","source":"Runner r14 single-engine browser UI; selected .track tile renderer added from simulator atlas","source_sha256":"65d1e5f2c4e19b4951b828e82510005ab99a5270cf3dcb9f4eaa0fa1af8c40f8"},"identity_note":"The historical source fields describe the base frontend; local packaged file hashes describe this candidate's derived frontend.","local_customization_id":"v1.2-winners-frozen-evaluation","packaged_frontend_files":{"assets/track-atlas.json":"d97c8900e3e5fb17734b5bd61d1f4f4b196d9be30af9848e2e273ae7e4079ae4","client.js":"687819451dae80b0d8df13346cdf08c93fcb15e6826af62d8c0667673f62ef3e","hf-auth.js":"3f3938bbc0935e4e9230c094029ef46e03beea74be199887c50e053e03dafcfe","index.html":"c46f7ba6dccf473956e038bf2028ff6d88b494a49d0c04c7ec0e278fd8eec0b3","track-library.js":"351ec4c026b49420ce963f4310cb000d9e987fd28e6dac5ecd0176509340f6e6","track-map.js":"ab5374aa49c7ccec90a787ee8c56cd71beb56b903bf2bbc322783e6f43c009f0"},"packaged_frontend_sha256":"e4a1c99827b8ed60dcdbc6639bff3d591dfd53d174d535133c4120dc8b15157a"}
+{"base_provenance":{"output_sha256":"a145fbb303a85c728a530d98fbea998677c1c62a2589c46af9b8b287e4ce1f48","scope":"Frontend only; no engine, private data, track assets, API calls or storage copied","source":"Runner r14 single-engine browser UI; selected .track tile renderer added from simulator atlas","source_sha256":"65d1e5f2c4e19b4951b828e82510005ab99a5270cf3dcb9f4eaa0fa1af8c40f8"},"identity_note":"The historical source fields describe the base frontend; local packaged file hashes describe this candidate's derived frontend.","local_customization_id":"v1.2-winners-frozen-evaluation","packaged_frontend_files":{"assets/track-atlas.json":"d97c8900e3e5fb17734b5bd61d1f4f4b196d9be30af9848e2e273ae7e4079ae4","client.js":"747b85d297a9459ce17aefb468b3688f24e2efc6b6e1598f6b8da48d3b63a677","hf-auth.js":"3f3938bbc0935e4e9230c094029ef46e03beea74be199887c50e053e03dafcfe","index.html":"6f1b8992ed6bb8483ac09ef24c85da01f23e4a8df2b807a7f7fe5e67d4da27ed","track-library.js":"351ec4c026b49420ce963f4310cb000d9e987fd28e6dac5ecd0176509340f6e6","track-map.js":"ab5374aa49c7ccec90a787ee8c56cd71beb56b903bf2bbc322783e6f43c009f0"},"packaged_frontend_sha256":"4bb0f248bf75289d0d67c6d57b1dad80216e575b352f0664931f49ea5df3ca47"}

RELEASE_MANIFEST.json

@@ -1 +1 @@
-{"backend":"gpu","files":{".gitattributes":"c2ad16718fc51c888d32efc88c8f6e23ebe5fcf6f48e2954f896ba9770f24d72","BETA_TESTING.md":"27e2492f9fe87cc04f52de2974b685b44041f7de9fa1155926b66c436f0bc613","BINARY_PROVENANCE.json":"a0da1328fde0fb141d232c563ca5b217a4e9e50da62ba818ccb148a1529c9680","BUCKET_BUNDLE.md":"a802f658220f5eabc1a98ea4a5217989b54084d4993943c1faafbad36d421131","CUDA_REFERENCE.md":"f7453c3254d244f8b0de41fde5851cb025159f5cea4a4d1a5d8208a955550c6c","DATA_POLICY.md":"7e8b31b5ad30f35e5d7242c13bdb356191ae05c81dcea2709172974e82546e4d","FEEDBACK.md":"f95b8f6afbf4a360976c0edca5d52f5b3a0b668c9a944d4947b840a7c53a122a","FRONTEND_SOURCE.json":"d7a634aeceadb4268a38518a53a3b66c38d4b24cf3fbb8545b70828ee36bb279","GODOT_LICENSE":"fb2b3bb82c60f1e76841ba2122eb902f8e39c151476fe21ce10c9a05d1045304","IMPORTER_BUILD_RECEIPT.json":"4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d","LICENSE":"53d5851b6440feeae36f72a5f57fcab37858c48b7084765ece4b0c54b9a28ed8","README.md":"cb234a47d1aef9ec17ac72cddca0d7b82abe868cbd3acd992bb8abb0759a18c2","STORAGE_BOUNDARY.md":"ac6946e1fd54be0786d71c24ec499bb898e63c20fd064c3c0bb3bba7046a0c57","TRACK_LIBRARY.md":"66b3656ed84f137d5b6116a0075731cd467818f555cca0969084aff67875319f","UPSTREAM.json":"148fd5b06f9b7f2d6830f5b536bf05dfc95c772f124223e8e298acc77f330836","WINNERS_AND_EVALUATION.md":"c3df1b0e7c6ce76c2660159c9b74bd7c35af02be2fcad1b8022e3bb47677bebe","analysis_result.py":"0a5d73fe8dbca934b21823b8ffbd50b0baaef8e15a39e32604eefe16f01d1cf2","app.py":"78ddccd56e5c217b89681c5dcbee451b6a5868398c4f75bd2b4db33c235d800f","app_release.py":"7482559c667a665fd3cb6aa8af6c78422a822b515e14589db8306f7fd4860a8b","assets/formula_template.json":"80f745df82bb7be45af52785fd582460bcddc63c5a4e1d8375d85b3122db4c6b","assets/rally_template.json":"7350a3fe28d9b4da7a0965ae6ea7ca3472fb7885303e342310d63a0dce80851c","assets/snowmobile_template.json":"12d30545876011fd6fccdd3e721f9c465938c9c58ac99338205481d5e7ac6742","assets/track-atlas.json":"d97c8900e3e5fb17734b5bd61d1f4f4b196d9be30af9848e2e273ae7e4079ae4","assets/truck_template.json":"a83bffea4d5e818c135ab3aba68a47aa288d6ad0e7b8bd9c95ed0dea9e9df2f7","bin/altd-sim":"6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d","bin/extract_saved_track":"3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a","bin/libaltd_gpu.so":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca","bucket_storage.py":"4cdc4dc37388484fdd696e6932062ca20651c5ad64cd91a8ba059e92f90ca752","build_info.py":"03efdd1bca81022669a9184667b89d4f1096faba6a83c0514322dd419a938e1f","builtin_tracks.py":"2ecc2b1d00fe15701b0271d71e1e68d2e7e59c596330879494055f9b2a99c242","builtin_tracks/catalog.json":"65006e70a87a5a53e3738166b0895bc4db9f99767dd891d917b68029abb4e80a","builtin_tracks/tracks/Replica A01 Beginner.track":"ca5749537450430794e2eade2e0ac72fa141a4f225e13e2f8ef842abb948ff15","builtin_tracks/tracks/Replica A02 Sharp Turns.track":"097f1ea8edf041112b690d0638075630716ddc03c7d0b1980ddcbeaf5071c8d4","builtin_tracks/tracks/Replica A03 High Speed.track":"88917c63847be1854b989bb28a23af7eeacb964c3e7df9579953aebc9496e6af","builtin_tracks/tracks/Replica A04 Dirt.track":"7f4fe58516227b15898d14bb0abb9a0856126d24fcd793884f051f7a4fae521d","builtin_tracks/tracks/Replica A05 Two Terrains.track":"c4ee2842920d99cdfe3eebdcad59a77e24b626380acef0d02a39ea1e23823e2a","builtin_tracks/tracks/Replica A06 Ice.track":"fccb9a159a06d1b986c6fe7d5bb89c0cabad3a005531f4e0d71f6e37254ada34","builtin_tracks/tracks/Replica A07 Three Terrains.track":"a8fa652ad451e2702a23d5f3429eb0b6a6408bf6a2a76a73d549023e481875c6","builtin_tracks/tracks/Replica A08 Long.track":"3e259bd227776ca847d35baaea88b5e8af57cc920643bf71563176bd6554ad65","builtin_tracks/tracks/Replica A09 Sharpest.track":"5362cea3c564dce8f4f22fcd4b798347931dfaa4e65b84624944952b3e0b0d2a","builtin_tracks/tracks/Replica B01 Oval.track":"0df5755150c145a35edc6c8693f429e5b9ff4b12210ba67cbfcb932c58faf158","builtin_tracks/tracks/Replica B02 Snake.track":"210e699b1fa5f2624a2ff0969b73a20af7bc56bf774f4fd282f6109f80bfdb3c","builtin_tracks/tracks/Replica B03 Slalom.track":"a8bab86f93e3072bf27a81a354220c137207b9fc0b548372c8dab93639a18a24","builtin_tracks/tracks/Replica B04 Rally.track":"9d2fc668a7c86aabb9ca9dbfdbd21dff0d099c5d77029aa2ae96b6c7b9efd3f0","builtin_tracks/tracks/Replica B05 Racetrack.track":"d0804ebc17646d2f7c3be65cfe0f6e94033417e75b101a8c598a69131a170079","builtin_tracks/tracks/Replica B06 Hard.track":"8b1a10fd8485405d7f73abca8890f4845145227177c9ac07ac9a1d79f28908f9","builtin_tracks/tracks/Replica B07 Drift.track":"d6d46216882cb63d55b1e8ce81ffa67f1c95ffd0a86a72806b8fd23973c6ce0a","builtin_tracks/tracks/Replica B08 Arctic Circle.track":"229128e86a87089f781b072a4c677ff729cf8488b1d74ad75cfb43655b9f4a16","builtin_tracks/tracks/Replica B09 Checkered.track":"bec4dbd0edc35e0e4f4d1035c608a0c56bbc99e7301f640f8e2eddba0100b2fe","builtin_tracks/tracks/Replica R01 Blitzring.track":"14b52a7cbbf7de5606c772c74730c0e8776f39ed72955fef5ae1f7c2d8ccef77","builtin_tracks/tracks/Replica R02 Desert Rally.track":"653286b00f2f04450e698d8b8e9d4ecb268064b323b182d2de9db7d017b22238","builtin_tracks/tracks/Replica R03 Glacier.track":"0e1b42ce51ae91a8702e173013a090d00145e518bb47d7a659cb1d1fdff011b5","builtin_tracks/tracks/Replica R04 Truck Maze.track":"d7b89d64e118506e6cec259057886d9267ca4c6fab570e7ba0d6641e8f822f11","builtin_tracks/tracks/Replica R05 Endurance 500.track":"dde36ad5f627bce65d45a96d46a68497f8d446f6011c9df19ee51ce71375cba8","builtin_tracks/tracks/Replica R06 Mix.track":"9de8d912a59001ea13baa7f1b4f92884b8cddf91978f31e19f3237975713f739","builtin_tracks/tracks/Replica R07 Mirage Marina.track":"8c6764f3accb1a8372d910d57f4f681572dd40c590c4a3d03517379bb360fcd7","builtin_tracks/tracks/Replica R08 Demolition Derby.track":"6f11a9ffbcb477c9d19964566b1b612d2a94675605246e93e21f27bbbdb357ef","builtin_tracks/tracks/Replica R09 Eau Noir.track":"3ec0a78478cca1a4f0d2d98ac81f40783928adf271b70f0c32d295a6da2cdaa9","builtin_tracks/tracks/Replica The Champions Trial.track":"a3bfb76422affc774b44c739b0636d08acb901fa7615b9adcb52c069f79834e1","client.js":"687819451dae80b0d8df13346cdf08c93fcb15e6826af62d8c0667673f62ef3e","delivery.py":"6bdba2e87c3e19a41440cb16103695af27105f8bafbae38948bbb1b936ed0c1b","gpu_tickets.py":"b81aadb5ed42cec9212d44da7e7bbb7b413c5bd517383cac0b49ec9b4d659c92","hf-auth.js":"3f3938bbc0935e4e9230c094029ef46e03beea74be199887c50e053e03dafcfe","hf_identity.py":"913fb1e089af21f376e8359a20cbc838d5bcd7971def6989a4382d53c1127b37","index.html":"c46f7ba6dccf473956e038bf2028ff6d88b494a49d0c04c7ec0e278fd8eec0b3","native/analysis.patch":"56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63","native/build-receipt.json":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","native/source-receipt.json":"33d09c326e4d6c3ac1d1839e4528c70c06b4ff48138b90f174f434ab685b4b34","portable_bundle.py":"29ab4e728eb054a51d02d41114a3548c6ed7cee65f809e0f33da40b87e0a12a6","requirements.txt":"fc7e0703ad2289fd3926a36efbdce8c61f0edc00f7575a87e2b565e46588c5a4","server.py":"a8f838ee9f9a7a30d977fb706337ae070bba16a7f90aad9ad66f96e1a6a0eb21","steam_leaderboard.py":"d76397c39cae58f636ddf9a9be1a46ae3d77fefd6b7269feac73d34d97165481","track-library.js":"351ec4c026b49420ce963f4310cb000d9e987fd28e6dac5ecd0176509340f6e6","track-map.js":"ab5374aa49c7ccec90a787ee8c56cd71beb56b903bf2bbc322783e6f43c009f0","training_config.py":"3d7fcaad585b474380e825649e4add3412494bbd68b48b3b14bd1b954e817ad0","vendor/gradio-client/LICENSE":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","vendor/gradio-client/dist/index.min.js":"fdd776db8633354f118fe2908c980592283968737e6b91dc3aa86d648da5c3fd","vendor/gradio-client/package.json":"96c5b9e6d3587fb7bd8e5bb28775ece222de1043045afc4e6389c88db137ad0e","vendor/hf-oauth/LICENSE":"d6e7b19451c1b3d1d66353bb4b1274138953b3bfd9ae60c56e77b1f548796982","vendor/hf-oauth/index.js":"53282844000a171011e547f6472a3846bb4cecb5071adafea079fcac3a2aee7e","vendor/hf-oauth/package.json":"fafd4d8891023a1961546a7d3bc25cd24f64923a2ebfc449fe6d516a2949bda8","worker.py":"0c32f658c4c7af8c6f59f039b8bafdd997f324fcb12340f238e46a2d009d4e9f"},"interface":"single-engine-runner-with-map-winners-analysis-v1","upstream_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"}
+{"backend":"gpu","files":{".gitattributes":"c2ad16718fc51c888d32efc88c8f6e23ebe5fcf6f48e2954f896ba9770f24d72","BETA_TESTING.md":"27e2492f9fe87cc04f52de2974b685b44041f7de9fa1155926b66c436f0bc613","BINARY_PROVENANCE.json":"fa2b6c8962a0ec704ce7db417e7747abfc8af79f9f31effd242c013d8bdeca5f","BUCKET_BUNDLE.md":"a802f658220f5eabc1a98ea4a5217989b54084d4993943c1faafbad36d421131","CUDA_REFERENCE.md":"f7453c3254d244f8b0de41fde5851cb025159f5cea4a4d1a5d8208a955550c6c","DATA_POLICY.md":"7e8b31b5ad30f35e5d7242c13bdb356191ae05c81dcea2709172974e82546e4d","FEEDBACK.md":"f95b8f6afbf4a360976c0edca5d52f5b3a0b668c9a944d4947b840a7c53a122a","FRONTEND_SOURCE.json":"d684d7aefd4ea5a332571b80abd435911b22c7ae883372dcd4f7f7acc8ca1ffe","GODOT_LICENSE":"fb2b3bb82c60f1e76841ba2122eb902f8e39c151476fe21ce10c9a05d1045304","IMPORTER_BUILD_RECEIPT.json":"4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d","LICENSE":"53d5851b6440feeae36f72a5f57fcab37858c48b7084765ece4b0c54b9a28ed8","README.md":"cb234a47d1aef9ec17ac72cddca0d7b82abe868cbd3acd992bb8abb0759a18c2","STORAGE_BOUNDARY.md":"ac6946e1fd54be0786d71c24ec499bb898e63c20fd064c3c0bb3bba7046a0c57","TRACK_LIBRARY.md":"be64c91633ef6696233df537afeef4c5175b2d55daac9336758d9eb3d24763c9","UPSTREAM.json":"e71d256ab4fea9a684c211f91086cd8a3eec518686eb54474e79352b20eeed79","WINNERS_AND_EVALUATION.md":"c3df1b0e7c6ce76c2660159c9b74bd7c35af02be2fcad1b8022e3bb47677bebe","analysis_result.py":"0a5d73fe8dbca934b21823b8ffbd50b0baaef8e15a39e32604eefe16f01d1cf2","app.py":"78ddccd56e5c217b89681c5dcbee451b6a5868398c4f75bd2b4db33c235d800f","app_release.py":"7482559c667a665fd3cb6aa8af6c78422a822b515e14589db8306f7fd4860a8b","assets/formula_template.json":"80f745df82bb7be45af52785fd582460bcddc63c5a4e1d8375d85b3122db4c6b","assets/rally_template.json":"7350a3fe28d9b4da7a0965ae6ea7ca3472fb7885303e342310d63a0dce80851c","assets/snowmobile_template.json":"12d30545876011fd6fccdd3e721f9c465938c9c58ac99338205481d5e7ac6742","assets/track-atlas.json":"d97c8900e3e5fb17734b5bd61d1f4f4b196d9be30af9848e2e273ae7e4079ae4","assets/truck_template.json":"a83bffea4d5e818c135ab3aba68a47aa288d6ad0e7b8bd9c95ed0dea9e9df2f7","bin/altd-sim":"3aa1d364e0117f553a52404ae336efcfebd827fc0ca347e811196cbe31e32849","bin/extract_saved_track":"3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a","bin/libaltd_gpu.so":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca","bucket_storage.py":"73977f5c23c513848a6451fd603609211d829126438db803288ebf4469d1893d","build_info.py":"03efdd1bca81022669a9184667b89d4f1096faba6a83c0514322dd419a938e1f","builtin_tracks.py":"52cb4a285a6079cec7f7610de8af80570f1644a02cf9979e47d2d49736e24cb5","builtin_tracks/catalog.json":"65006e70a87a5a53e3738166b0895bc4db9f99767dd891d917b68029abb4e80a","builtin_tracks/tracks/Replica A01 Beginner.track":"ca5749537450430794e2eade2e0ac72fa141a4f225e13e2f8ef842abb948ff15","builtin_tracks/tracks/Replica A02 Sharp Turns.track":"097f1ea8edf041112b690d0638075630716ddc03c7d0b1980ddcbeaf5071c8d4","builtin_tracks/tracks/Replica A03 High Speed.track":"88917c63847be1854b989bb28a23af7eeacb964c3e7df9579953aebc9496e6af","builtin_tracks/tracks/Replica A04 Dirt.track":"7f4fe58516227b15898d14bb0abb9a0856126d24fcd793884f051f7a4fae521d","builtin_tracks/tracks/Replica A05 Two Terrains.track":"c4ee2842920d99cdfe3eebdcad59a77e24b626380acef0d02a39ea1e23823e2a","builtin_tracks/tracks/Replica A06 Ice.track":"fccb9a159a06d1b986c6fe7d5bb89c0cabad3a005531f4e0d71f6e37254ada34","builtin_tracks/tracks/Replica A07 Three Terrains.track":"a8fa652ad451e2702a23d5f3429eb0b6a6408bf6a2a76a73d549023e481875c6","builtin_tracks/tracks/Replica A08 Long.track":"3e259bd227776ca847d35baaea88b5e8af57cc920643bf71563176bd6554ad65","builtin_tracks/tracks/Replica A09 Sharpest.track":"5362cea3c564dce8f4f22fcd4b798347931dfaa4e65b84624944952b3e0b0d2a","builtin_tracks/tracks/Replica B01 Oval.track":"0df5755150c145a35edc6c8693f429e5b9ff4b12210ba67cbfcb932c58faf158","builtin_tracks/tracks/Replica B02 Snake.track":"210e699b1fa5f2624a2ff0969b73a20af7bc56bf774f4fd282f6109f80bfdb3c","builtin_tracks/tracks/Replica B03 Slalom.track":"a8bab86f93e3072bf27a81a354220c137207b9fc0b548372c8dab93639a18a24","builtin_tracks/tracks/Replica B04 Rally.track":"9d2fc668a7c86aabb9ca9dbfdbd21dff0d099c5d77029aa2ae96b6c7b9efd3f0","builtin_tracks/tracks/Replica B05 Racetrack.track":"d0804ebc17646d2f7c3be65cfe0f6e94033417e75b101a8c598a69131a170079","builtin_tracks/tracks/Replica B06 Hard.track":"8b1a10fd8485405d7f73abca8890f4845145227177c9ac07ac9a1d79f28908f9","builtin_tracks/tracks/Replica B07 Drift.track":"d6d46216882cb63d55b1e8ce81ffa67f1c95ffd0a86a72806b8fd23973c6ce0a","builtin_tracks/tracks/Replica B08 Arctic Circle.track":"229128e86a87089f781b072a4c677ff729cf8488b1d74ad75cfb43655b9f4a16","builtin_tracks/tracks/Replica B09 Checkered.track":"bec4dbd0edc35e0e4f4d1035c608a0c56bbc99e7301f640f8e2eddba0100b2fe","builtin_tracks/tracks/Replica R01 Blitzring.track":"14b52a7cbbf7de5606c772c74730c0e8776f39ed72955fef5ae1f7c2d8ccef77","builtin_tracks/tracks/Replica R02 Desert Rally.track":"653286b00f2f04450e698d8b8e9d4ecb268064b323b182d2de9db7d017b22238","builtin_tracks/tracks/Replica R03 Glacier.track":"0e1b42ce51ae91a8702e173013a090d00145e518bb47d7a659cb1d1fdff011b5","builtin_tracks/tracks/Replica R04 Truck Maze.track":"d7b89d64e118506e6cec259057886d9267ca4c6fab570e7ba0d6641e8f822f11","builtin_tracks/tracks/Replica R05 Endurance 500.track":"dde36ad5f627bce65d45a96d46a68497f8d446f6011c9df19ee51ce71375cba8","builtin_tracks/tracks/Replica R06 Mix.track":"9de8d912a59001ea13baa7f1b4f92884b8cddf91978f31e19f3237975713f739","builtin_tracks/tracks/Replica R07 Mirage Marina.track":"8c6764f3accb1a8372d910d57f4f681572dd40c590c4a3d03517379bb360fcd7","builtin_tracks/tracks/Replica R08 Demolition Derby.track":"6f11a9ffbcb477c9d19964566b1b612d2a94675605246e93e21f27bbbdb357ef","builtin_tracks/tracks/Replica R09 Eau Noir.track":"3ec0a78478cca1a4f0d2d98ac81f40783928adf271b70f0c32d295a6da2cdaa9","builtin_tracks/tracks/Replica The Champions Trial.track":"a3bfb76422affc774b44c739b0636d08acb901fa7615b9adcb52c069f79834e1","client.js":"747b85d297a9459ce17aefb468b3688f24e2efc6b6e1598f6b8da48d3b63a677","delivery.py":"6bdba2e87c3e19a41440cb16103695af27105f8bafbae38948bbb1b936ed0c1b","gpu_tickets.py":"b81aadb5ed42cec9212d44da7e7bbb7b413c5bd517383cac0b49ec9b4d659c92","hf-auth.js":"3f3938bbc0935e4e9230c094029ef46e03beea74be199887c50e053e03dafcfe","hf_identity.py":"913fb1e089af21f376e8359a20cbc838d5bcd7971def6989a4382d53c1127b37","index.html":"6f1b8992ed6bb8483ac09ef24c85da01f23e4a8df2b807a7f7fe5e67d4da27ed","native/analysis.patch":"42f79de67cb0734cffb2a7582f5479cab42ab82675884b8b42b9f158d46a98e8","native/build-receipt.json":"559a7e4e382f9f7caa1c5ceb566a5a0bbefad2ed3a2e2cf604e31c9c3890c348","native/source-receipt.json":"36feba861501baf8672884476bbeed5e375254cbb4feffb9f4f90aa61a415a93","portable_bundle.py":"aeeb2a81bcdf50bd013f3fa76e20c7c955c8f15344836596cd1043b1b7171026","requirements.txt":"fc7e0703ad2289fd3926a36efbdce8c61f0edc00f7575a87e2b565e46588c5a4","server.py":"da8ade96d68b89f328ee371d177f7272bd6f1d78832bff34c6eedaa3fe93ef96","star_check.py":"61d35bcede5dab75911b2734ff20cb38f7a06bde9fd58c2eff67f5833b260d40","steam_leaderboard.py":"d76397c39cae58f636ddf9a9be1a46ae3d77fefd6b7269feac73d34d97165481","track-library.js":"351ec4c026b49420ce963f4310cb000d9e987fd28e6dac5ecd0176509340f6e6","track-map.js":"ab5374aa49c7ccec90a787ee8c56cd71beb56b903bf2bbc322783e6f43c009f0","training_config.py":"3d7fcaad585b474380e825649e4add3412494bbd68b48b3b14bd1b954e817ad0","vendor/gradio-client/LICENSE":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","vendor/gradio-client/dist/index.min.js":"fdd776db8633354f118fe2908c980592283968737e6b91dc3aa86d648da5c3fd","vendor/gradio-client/package.json":"96c5b9e6d3587fb7bd8e5bb28775ece222de1043045afc4e6389c88db137ad0e","vendor/hf-oauth/LICENSE":"d6e7b19451c1b3d1d66353bb4b1274138953b3bfd9ae60c56e77b1f548796982","vendor/hf-oauth/index.js":"53282844000a171011e547f6472a3846bb4cecb5071adafea079fcac3a2aee7e","vendor/hf-oauth/package.json":"fafd4d8891023a1961546a7d3bc25cd24f64923a2ebfc449fe6d516a2949bda8","worker.py":"9d7d0d8e8730067658bbd6d5cddb20dca194a42cf885d389e193784fe8f15438"},"interface":"single-engine-runner-with-map-winners-analysis-v1","upstream_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"}

TRACK_LIBRARY.md

@@ -12,9 +12,13 @@ contains each file's SHA-256 and byte count. Private provenance paths, original
 packaged files, artwork, textures, opponents/controllers, original race parameters
 and the native geometry catalog are not part of this library.
 
-Training-track numeric challenge conditions were preserved. Race replicas use
-dummy lap stars rather than claiming to reproduce opponent challenges. The HF
-worker does not evaluate these conditions or grant campaign stars. Availability
+Training-track numeric challenge conditions were preserved. After each run the
+worker checks supported conditions in a fresh fixed-weight replay of the primary
+result. This predicts this network's performance only; it grants no campaign
+stars and carries no progression between runs. Race replicas contain dummy lap
+conditions in their editor files. The star checker recognizes those built-in
+files and reports their original opponent races as not checked, rather than
+counting placeholder laps as original-game stars. Availability
 in this selector is not a claim of official game approval, legal clearance,
 game-editor load verification, physics parity or leaderboard qualification.
 

UPSTREAM.json

@@ -1 +1 @@
-{"commit":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0","importer_source_revision":"d8ab74c25df70b6a86ed101080e33d5fb785ea6f","math_profile":"proton","native_build":{"build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","cuda_library_origin":"retained b90 CUDA library; layout ABI checked, no local device execution","patch_path":"native/analysis.patch","patch_sha256":"56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63","simulator_origin":"locally built Linux executable from b90 plus reviewed local patch","source_receipt_path":"native/source-receipt.json","source_receipt_sha256":"33d09c326e4d6c3ac1d1839e4528c70c06b4ff48138b90f174f434ab685b4b34","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"},"open_prs_not_included":[19,21],"repository":"https://github.com/Zorro909/driving_sim_rs","role":"gpu","ui_refresh_date":"2026-10-12"}
+{"commit":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0","importer_source_revision":"d8ab74c25df70b6a86ed101080e33d5fb785ea6f","math_profile":"proton","native_build":{"build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"559a7e4e382f9f7caa1c5ceb566a5a0bbefad2ed3a2e2cf604e31c9c3890c348","cuda_library_origin":"retained b90 CUDA library; layout ABI checked, no local device execution","patch_path":"native/analysis.patch","patch_sha256":"42f79de67cb0734cffb2a7582f5479cab42ab82675884b8b42b9f158d46a98e8","simulator_origin":"locally built Linux executable from b90 plus reviewed local patch","source_receipt_path":"native/source-receipt.json","source_receipt_sha256":"36feba861501baf8672884476bbeed5e375254cbb4feffb9f4f90aa61a415a93","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"},"open_prs_not_included":[19,21],"repository":"https://github.com/Zorro909/driving_sim_rs","role":"gpu","ui_refresh_date":"2026-10-12"}

bin/altd-sim

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d
-size 3580296
+oid sha256:3aa1d364e0117f553a52404ae336efcfebd827fc0ca347e811196cbe31e32849
+size 3604272

bucket_storage.py

@@ -342,6 +342,17 @@ def _save_files(bundle_bytes: bytes, bundle: dict, files: dict[str, bytes], *, n
         for name, content in files.items():
             if name.startswith("analysis/"):
                 uploads[name] = content
+        if "analysis/stars.json" in files:
+            stars=json.loads(files["analysis/stars.json"])
+            # Plain text avoids interpreting user-provided track labels as markup.
+            lines=["Star challenge check for the run's primary network", stars['basis'],
+                   "This check grants no game stars and keeps no campaign progression.",
+                   "Policy: "+stars['network_sha256'],
+                   "Check duration: "+str(stars['horizon_seconds'])+" seconds", ""]
+            for challenge in stars['challenges']:
+                lines.extend([challenge['text'], "Result: "+challenge['status'].replace('_',' '),
+                              "Reason: "+(challenge['reason'] or 'Condition observed.'), ""])
+            uploads['star-check.txt']=("\n".join(lines)+"\n").encode('utf-8')
         for role in ("fitness", "fastest_lap", "clean_laps"):
             name = f"analysis/winners/{role}.evolution"
             if name in files:

builtin_tracks.py

@@ -39,7 +39,7 @@ class TrackLibrary:
         return {'schema':'ald-builtin-track-library-v1',
                 'method':'programmatically reconstructed editor-format replicas',
                 'editor_authored':False,'clean_room':False,
-                'challenge_runtime_status':'not evaluated by this app',
+                'challenge_runtime_status':'per-run fixed-policy prediction; original opponent races not evaluated',
                 'tracks':[dict(entry) for _,entry in self._entries.values()]}
 
     def read(self, identifier):

client.js

@@ -530,6 +530,7 @@ async function acknowledge(current,received){
 }
 async function sha(bytes){return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256',bytes)),x=>x.toString(16).padStart(2,'0')).join('');}
 const ANALYSIS_ARCHIVE_MAX=32*1024*1024,ANALYSIS_EXPANDED_MAX=256*1024*1024,ANALYSIS_ROWS_MAX=128000;
+const STAR_CHECK_MAX=512*1024;
 const hex64=value=>typeof value==='string'&&/^[a-f0-9]{64}$/.test(value);
 function exactAnalysisKeys(value,keys){if(!value||typeof value!=='object'||Array.isArray(value)||Object.keys(value).sort().join()!==[...keys].sort().join())throw Error('Analysis archive contains unexpected fields');}
 function stableJson(value){if(Array.isArray(value))return '['+value.map(stableJson).join(',')+']';if(value&&typeof value==='object')return '{'+Object.keys(value).sort().map(key=>JSON.stringify(key)+':'+stableJson(value[key])).join(',')+'}';return JSON.stringify(value);}
@@ -596,8 +597,35 @@ function validateComparisonRequest(plan,actual){
     throw Error('The frozen comparison conditions or selected policy changed. The comparison was stopped before sending this run. Start a new comparison after restoring the matching settings.');
   return true;
 }
+function renderStarCheck(){
+  const panel=$('starCheckPanel');if(!panel)return;
+  const status=$('starCheckStatus'),details=$('starCheckDetails'),rows=$('starCheckRows');rows.replaceChildren();
+  panel.hidden=!(localResult||localAnalysis);
+  if(!localResult&&!localAnalysis){status.textContent='';details.hidden=true;return;}
+  if(pairedAnalysisPending){status.textContent='Challenge check is pending until the result and its analysis are fully verified.';details.hidden=true;return;}
+  const check=localAnalysis?.starCheck;
+  if(!check){status.textContent='No challenge check was included in this result archive. Older results may not contain one.';details.hidden=true;return;}
+  details.hidden=false;
+  const summary=localAnalysis.summary,policyHash=check.network_sha256;
+  const policy=summary.mode==='evaluate'?'Frozen evaluation input':`Final fitness leader from this run${summary.winners?.fitness?.candidate_id?' · '+summary.winners.fitness.candidate_id:''}`;
+  $('starCheckPolicy').textContent=policy+' · '+policyHash.slice(0,12);
+  $('starCheckPolicy').title=policyHash;
+  status.textContent=check.status==='complete'?'Challenge check completed for the policy named below. It does not award or accumulate game stars.':check.status==='unavailable'?'Challenge check was unavailable for the policy named below.':'No star challenges are defined for this selected replica track.';
+  $('starCheckBasis').textContent=check.basis;
+  const vehicle=['Formula','Rally','Snowmobile','Truck'][check.vehicle_type]??'Unknown vehicle';
+  $('starCheckConditions').textContent=vehicle+' · '+(check.execution_backend==='cuda'?'CUDA':'CPU')+' · horizon '+check.horizon_seconds.toFixed(2)+' s · collision elimination '+(check.collision_elimination?'on':'off');
+  const resultLabels={met:'Met',not_met:'Not met',not_checked:'Not checked'};
+  for(const challenge of check.challenges){
+    const tr=document.createElement('tr'),name=document.createElement('td'),result=document.createElement('td'),reason=document.createElement('td'),time=document.createElement('td');
+    name.textContent=challenge.text||challenge.id;name.title=challenge.id+' · '+challenge.type;
+    result.textContent=resultLabels[challenge.status];reason.textContent=challenge.reason??'No additional reason reported.';
+    time.textContent=challenge.completion_seconds===null?'Not recorded':challenge.completion_seconds.toFixed(3)+' s';
+    tr.append(name,result,reason,time);rows.append(tr);
+  }
+}
 function renderAnalysisPanel(){
   const panel=$('analysisPanel');if(!panel)return;
+  renderStarCheck();
   panel.hidden=!localAnalysis;
   if(!localAnalysis){$('winnerTools').hidden=true;$('evaluationTools').hidden=true;$('winnerRows').replaceChildren();$('winner_continue').replaceChildren();$('evaluationRows').replaceChildren();return;}
   const {summary}=localAnalysis,train=summary.mode==='train';
@@ -714,12 +742,13 @@ async function parseRunAnalysisArchive(bytes,descriptor,reportedSummary){
   if(descriptor.format!==undefined&&descriptor.format!=='ald.run-analysis-archive+gzip')throw Error('Unsupported analysis archive format');
   const raw=await expandAnalysisGzip(bytes);let envelope;
   try{envelope=JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(raw));}catch{throw Error('Analysis archive is not valid UTF-8 JSON');}
-  exactAnalysisKeys(envelope,['schema','version','files']);if(envelope.schema!=='ald.run-analysis-archive'||envelope.version!==1||!Array.isArray(envelope.files)||envelope.files.length>6)throw Error('Analysis archive envelope is invalid');
-  const files=new Map(),allowed=new Set(['analysis.json','descriptors.jsonl','evaluation.json','winners/fitness.evolution','winners/fastest_lap.evolution','winners/clean_laps.evolution']);
+  exactAnalysisKeys(envelope,['schema','version','files']);if(envelope.schema!=='ald.run-analysis-archive'||envelope.version!==1||!Array.isArray(envelope.files)||envelope.files.length>7)throw Error('Analysis archive envelope is invalid');
+  const files=new Map(),allowed=new Set(['analysis.json','descriptors.jsonl','evaluation.json','stars.json','winners/fitness.evolution','winners/fastest_lap.evolution','winners/clean_laps.evolution']);
   for(const file of envelope.files){
     exactAnalysisKeys(file,['name','bytes','sha256','data_base64']);
-    if(typeof file.name!=='string'||!allowed.has(file.name)||files.has(file.name)||!Number.isInteger(file.bytes)||file.bytes<1||file.bytes>ANALYSIS_EXPANDED_MAX||!hex64(file.sha256))throw Error('Analysis archive file manifest is invalid');
-    const content=b64Bytes(file.data_base64,ANALYSIS_EXPANDED_MAX);
+    const fileMax=file.name==='stars.json'?STAR_CHECK_MAX:ANALYSIS_EXPANDED_MAX;
+    if(typeof file.name!=='string'||!allowed.has(file.name)||files.has(file.name)||!Number.isInteger(file.bytes)||file.bytes<1||file.bytes>fileMax||!hex64(file.sha256))throw Error('Analysis archive file manifest is invalid');
+    const content=b64Bytes(file.data_base64,fileMax);
     if(content.byteLength!==file.bytes||await sha(content)!==file.sha256)throw Error('Analysis archive inner file failed size or SHA-256 verification');
     files.set(file.name,{bytes:content,sha256:file.sha256});
   }
@@ -757,9 +786,42 @@ async function parseRunAnalysisArchive(bytes,descriptor,reportedSummary){
     if(evaluation.schema!=='ald.frozen-evaluation'||evaluation.version!==1||stableJson(evaluation.conditions)!==stableJson(summary.conditions)||evaluation.input_sha256!==summary.conditions.network_sha256||evaluation.weights_unchanged!==true)throw Error('Frozen evaluation identity is invalid');
     validateDescriptorRow(evaluation.measurements,metricNames,rewardChannels);
   }else if(files.has('evaluation.json'))throw Error('Training archive unexpectedly contains frozen evaluation data');
-  const expectedFiles=new Set(['analysis.json','descriptors.jsonl',...(summary.mode==='evaluate'?['evaluation.json']:[]),...Object.entries(summary.winners).filter(([,w])=>w.status==='available').map(([role])=>'winners/'+role+'.evolution')]);
+  let starCheck=null;
+  if(files.has('stars.json')){
+    try{starCheck=JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(files.get('stars.json').bytes));}catch{throw Error('Star check file is invalid JSON');}
+    validateStarCheck(starCheck,summary);
+  }
+  const expectedFiles=new Set(['analysis.json','descriptors.jsonl',...(summary.mode==='evaluate'?['evaluation.json']:[]),...(files.has('stars.json')?['stars.json']:[]),...Object.entries(summary.winners).filter(([,w])=>w.status==='available').map(([role])=>'winners/'+role+'.evolution')]);
   if(files.size!==expectedFiles.size||[...files.keys()].some(name=>!expectedFiles.has(name)))throw Error('Analysis archive contains missing or unexpected files');
-  return {mode:summary.mode,summary,analysis,winnerNetworks,evaluation,archiveBytes:bytes,descriptorText:descText,descriptorOffsets:offsets,descriptorRows,rawMetrics:metricNames,rewardChannels};
+  return {mode:summary.mode,summary,analysis,winnerNetworks,evaluation,starCheck,archiveBytes:bytes,descriptorText:descText,descriptorOffsets:offsets,descriptorRows,rawMetrics:metricNames,rewardChannels};
+}
+function validateStarCheck(value,summary){
+  exactAnalysisKeys(value,['schema','version','network_sha256','track_sha256','vehicle_type','execution_backend','status','horizon_seconds','collision_elimination','scope','basis','challenges']);
+  const expectedNetwork=summary.mode==='train'?summary.winners.fitness.artifact?.sha256:summary.conditions.network_sha256;
+  if(value.schema!=='ald.star-check'||value.version!==1||!hex64(value.network_sha256)||value.network_sha256!==expectedNetwork||
+     !hex64(value.track_sha256)||value.track_sha256!==summary.conditions.track_sha256||value.vehicle_type!==summary.conditions.vehicle_type||
+     value.execution_backend!==summary.execution_backend||!['complete','unavailable','no_challenges'].includes(value.status)||
+     !Number.isFinite(value.horizon_seconds)||value.horizon_seconds<0||value.horizon_seconds>300||
+     typeof value.collision_elimination!=='boolean'||value.collision_elimination!==summary.conditions.collision||
+     value.scope!=='current_network'||typeof value.basis!=='string'||!value.basis.length||value.basis.length>1000||
+     !Array.isArray(value.challenges)||value.challenges.length>64)throw Error('Star check identity or metadata is invalid');
+  if((value.status==='no_challenges')!==(value.challenges.length===0))throw Error('Star check status does not match its challenge list');
+  const ids=new Set();
+  for(const challenge of value.challenges){
+    exactAnalysisKeys(challenge,['id','type','text','status','reason','completion_seconds']);
+    if(typeof challenge.id!=='string'||!challenge.id.length||challenge.id.length>128||ids.has(challenge.id)||
+       typeof challenge.type!=='string'||!challenge.type.length||challenge.type.length>96||
+       typeof challenge.text!=='string'||challenge.text.length>256||
+       !['met','not_met','not_checked'].includes(challenge.status)||
+       !(challenge.reason===null||(typeof challenge.reason==='string'&&challenge.reason.length>0&&challenge.reason.length<=256))||
+       !(challenge.completion_seconds===null||(Number.isFinite(challenge.completion_seconds)&&challenge.completion_seconds>=0&&challenge.completion_seconds<=300)))throw Error('Star check challenge entry is invalid');
+    if(challenge.status==='met'){
+      if(challenge.reason!==null||challenge.completion_seconds===null||challenge.completion_seconds>value.horizon_seconds)throw Error('Completed challenge evidence is inconsistent');
+    }else if(challenge.reason===null||challenge.completion_seconds!==null)throw Error('Uncompleted challenge evidence is inconsistent');
+    if(value.status==='unavailable'&&challenge.status!=='not_checked')throw Error('Unavailable star check cannot report a challenge result');
+    ids.add(challenge.id);
+  }
+  return value;
 }
 function validatePrimaryAnalysisMatch(primarySha,parsed){
   if(!hex64(primarySha)||!parsed?.summary)throw Error('Primary result and analysis are not verifiable');
@@ -771,7 +833,7 @@ function validatePrimaryAnalysisMatch(primarySha,parsed){
   }else throw Error('Analysis mode is unsupported');
   return true;
 }
-window.RunAnalysis={parseArchive:parseRunAnalysisArchive,validatePrimaryMatch:validatePrimaryAnalysisMatch,validateComparisonRequest,uniqueWinnerRoles};
+window.RunAnalysis={parseArchive:parseRunAnalysisArchive,validatePrimaryMatch:validatePrimaryAnalysisMatch,validateComparisonRequest,uniqueWinnerRoles,validateStarCheck};
 function showDetails(r){
   const metric=n=>typeof n==='number'?n.toFixed(3):'Not reported';
   if($('effectiveSettings'))$('effectiveSettings').textContent=JSON.stringify(r?.settings??{},null,2);

index.html

@@ -28,8 +28,8 @@
   };
 })();
 </script>
-<header><div class="eyebrow">AI LEARNS TO DRIVE · TRAINING LAB</div><h1>Train, inspect, repeat.</h1><p class="intro">Pick a track and network, run a bounded training session, and keep your recipes in this browser.</p><details class="about"><summary>About this beta and its data handling</summary><p>Simulator by <a href="https://github.com/Zorro909/driving_sim_rs">Zorro909</a>; interface and hosting by <a href="https://github.com/seeker-cyber-maker/driving_sim_rs">TiGa</a>. Inspired by the <a href="https://store.steampowered.com/app/3312030/AI_Learns_To_Drive/">game by ActivationFunction</a>. Built-in tracks are reconstructed replicas. Star challenges are not evaluated here.</p><p>Uploaded files are used for the requested run. Results are held briefly in application memory and deleted after verified download or expiry. Browser recipes contain settings only. <a href="/policy" target="_blank" rel="noopener">Read the data policy</a>.</p></details><p><a id="feedbackLink" href="https://github.com/seeker-cyber-maker/driving_sim_rs/issues/new" target="_blank" rel="noopener">Report a problem on GitHub</a> · Opens an editable draft and never submits it. Review details before posting; export a run receipt separately if it helps explain the issue.</p><p id="buildLabel" class="hint">Build: connecting…</p></header>
-<nav class="tabs" aria-label="Lab sections"><button data-tab="drive" aria-selected="true">1 · Drive & view</button><button data-tab="training" aria-selected="false">2 · Training runs & presets</button><button data-tab="batch" aria-selected="false">3 · Batches</button><button data-tab="editor" aria-selected="false">4 · Network editor</button></nav><div id="drive" class="pane"><div class="grid"><section class="card"><h2>Simulation</h2><label for="run_mode">Action</label><select id="run_mode"><option value="train" selected>Train a population</option><option value="evaluate">Frozen evaluation · one policy, unchanged weights</option></select><p id="run_mode_help" class="hint">Training uses the selected recipe. Frozen evaluation runs the selected policy in a fresh car without changing its weights.</p><button id="run" disabled>Run training</button><p class="hint">Select or create a network below to enable training. Review settings on tab 2 before running.</p><p>Supports Formula, Rally, Snowmobile and Truck networks. Control outputs follow the original vehicle editor rules. Network shape and supported sensors are bounded by the original game contract.</p>
+<header><div class="eyebrow">AI LEARNS TO DRIVE · TRAINING LAB</div><h1>Train, inspect, repeat.</h1><p class="intro">Pick a track and network, run a bounded training session, and keep your recipes in this browser.</p><details class="about"><summary>About this beta and its data handling</summary><p>Simulator by <a href="https://github.com/Zorro909/driving_sim_rs">Zorro909</a>; interface and hosting by <a href="https://github.com/seeker-cyber-maker/driving_sim_rs">TiGa</a>. Inspired by the <a href="https://store.steampowered.com/app/3312030/AI_Learns_To_Drive/">game by ActivationFunction</a>. Built-in tracks are reconstructed replicas. For supported conditions, the lab checks the run’s final fitness policy (or frozen input) with a bounded fresh replay. It predicts conditions only and does not award or accumulate original-game stars; opponent races and other unsupported conditions remain unchecked.</p><p>Uploaded files are used for the requested run. Results are held briefly in application memory and deleted after verified download or expiry. Browser recipes contain settings only. <a href="/policy" target="_blank" rel="noopener">Read the data policy</a>.</p></details><p><a id="feedbackLink" href="https://github.com/seeker-cyber-maker/driving_sim_rs/issues/new" target="_blank" rel="noopener">Report a problem on GitHub</a> · Opens an editable draft and never submits it. Review details before posting; export a run receipt separately if it helps explain the issue.</p><p id="buildLabel" class="hint">Build: connecting…</p></header>
+<nav class="tabs" aria-label="Lab sections"><button data-tab="drive" aria-selected="true">1 · Drive & view</button><button data-tab="training" aria-selected="false">2 · Training runs & presets</button><button data-tab="batch" aria-selected="false">3 · Batches</button><button data-tab="editor" aria-selected="false">4 · Network editor</button></nav><div id="drive" class="pane"><div class="grid"><section class="card"><h2>Simulation</h2><label for="run_mode">Action</label><select id="run_mode"><option value="train" selected>Train a population</option><option value="evaluate">Frozen evaluation · one policy, unchanged weights</option></select><p id="run_mode_help" class="hint">Training uses the selected recipe. Frozen evaluation runs the selected policy in a fresh car without changing its weights.</p><button id="run" disabled>Run training</button><p id="starCheckNotice" class="hint">After a run, the app automatically checks challenges for the current network when this track provides them. It uses the same driving settings with fixed weights and the selected run duration, or the track's longer challenge deadline up to 300 seconds, so the run may take longer. It checks this network only; it does not award game stars or combine progress across runs.</p><p class="hint">Select or create a network below to enable training. Review settings on tab 2 before running.</p><p>Supports Formula, Rally, Snowmobile and Truck networks. Control outputs follow the original vehicle editor rules. Network shape and supported sensors are bounded by the original game contract.</p>
 <p id="computeBlock"><label for="backend">Compute</label><select id="backend" disabled><option value="cpu">CPU — no GPU allowance</option><option id="gpuOption" value="gpu" disabled>GPU — uses GPU allowance</option></select></p><p id="backendNote" class="hint">Checking available backends…</p>
 <div id="connectionRecovery" hidden><button id="retry" type="button">Reconnect to app</button><p class="hint">Checks server availability. Does not restart training, sign you in, or reset GPU allowance.</p></div>
 <div id="gpuAccount" aria-label="Optional GPU account"><p><button id="hfSignIn" type="button" disabled>Sign in with HF for account GPU allowance</button><span id="hfAccount" hidden></span> <button id="hfSignOut" type="button" disabled hidden>Disconnect account</button></p><p id="hfIdentity" role="status" class="hint">CPU needs no sign-in. Checking optional GPU account connection…</p>
@@ -57,12 +57,13 @@
 </div>
 <div id="evaluationTools" hidden><p id="evaluationStatus" role="status" aria-live="polite"></p><p class="hint">Frozen evaluation does not select winners or compare population-relative fitness. Each comparison row keeps its network hash and must match the same track, vehicle, horizon, control rate, collision/idle rules, backend and engine build.</p><button id="compare_add" type="button">Add this frozen result to comparison</button><div class="table-scroll"><table><thead><tr><th>Policy</th><th>Vehicle</th><th>Track</th><th>Ticks</th><th>Best lap</th><th>Forward laps</th><th>Physical contacts</th><th>Distance (simulation units)</th><th>Comparison</th></tr></thead><tbody id="evaluationRows"></tbody></table></div><button id="compare_clear" type="button">Clear comparison</button></div>
 </section>
+<section id="starCheckPanel" class="card" hidden aria-labelledby="starCheckTitle"><h2 id="starCheckTitle">Star challenge check</h2><p id="starCheckStatus" role="status" aria-live="polite"></p><div id="starCheckDetails" hidden><p id="starCheckPolicy" class="hint"></p><p id="starCheckBasis" class="hint"></p><p id="starCheckConditions" class="hint"></p><div class="table-scroll"><table><thead><tr><th>Challenge</th><th>Result</th><th>Reason</th><th>Completion time</th></tr></thead><tbody id="starCheckRows"></tbody></table></div><p class="hint">This is an independent check of the named run policy. It does not grant or accumulate original-game stars; replica challenges may differ from the original game.</p></div></section>
 <label class="keep-result"><input id="leaderboard_opt_in" type="checkbox"> After a completed lap, check its position against the public Steam leaderboard</label><p class="privacy-note">Optional, read-only check for supported built-in tracks. It sends the track ID and best lap to this app server; Steam receives only a public leaderboard read. No score is submitted. The result is an estimate, not an official rank.</p><p id="leaderboard_status" role="status" aria-live="polite"></p>
 <p><button id="run_export" disabled>Export run receipt</button> <button id="player_report_download" disabled>Download player report (.txt)</button> <button id="history_csv_download" disabled>Download generation history (.csv)</button></p><p class="hint">Reports use only server-reported run and generation fields. The engine does not report per-reward contribution, so reward weights are shown as configured values only.</p>
 <details id="portableBundle"><summary>Portable bucket bundle</summary><p>Build, export, or restore one validated bundle. Bucket storage is optional. When connected, automatic save is on by default; turn it off here to keep saves manual. Disconnected runs never call bucket storage.</p><label><input id="bundle_track" type="checkbox"> Include the selected track</label><label><input id="bundle_recipe" type="checkbox"> Include the recipe in the selected slot, if saved</label><label><input id="bundle_receipt" type="checkbox"> Include a sanitized receipt for the selected completed result</label><div class="toolbar"><button id="bundle_export" type="button">Export portable bundle</button><label for="bundle_import">Restore portable bundle (.json)<input id="bundle_import" type="file" accept=".json,application/json"></label><button id="bundle_receipt_download" type="button" disabled>Download staged receipt</button></div><p id="bundle_status" role="status" aria-live="polite">No bucket action has been requested.</p>
 <details id="bucketStorage"><summary>Connect to an existing private bucket</summary><p>Bucket storage is optional. Authorizing storage also identifies your account for GPU requests; ordinary GPU sign-in remains available with the basic identity permission. Then enter your existing private bucket ID. Connected runs automatically save by default; uncheck this option to keep run saves manual. No personal token is requested or stored.</p><p id="bucket_scope_notice" class="privacy-note">HF describes the requested <code>write-repos</code> permission as read/write access to your personal repositories. That grant is broader than one selected bucket and is not a bucket-only permission; the app limits its own operations to the bucket you enter. The minimum current scope for bucket read/write has not been confirmed by HF.</p><button id="bucket_authorize" type="button" hidden disabled>Authorize bucket access with HF</button><p id="bucket_auth_unavailable" class="hint" hidden>HF bucket authorization is unavailable for this app. Local bundle export remains available.</p><p id="bucket_auth_status" role="status" aria-live="polite">Checking optional HF bucket authorization…</p><div id="bucketConnectForm" hidden><label for="bucket_id">Private bucket ID</label><input id="bucket_id" type="text" autocomplete="off" placeholder="username/bucket-name" disabled><button id="bucket_connect" type="button" disabled>Connect bucket</button></div><div id="bucketConnected" hidden><p id="bucket_account"></p><label class="keep-result"><input id="bucket_autosave" type="checkbox" checked> Automatically save every verified completed network and run log to this bucket</label><p class="hint">For each completed run, the browser fetches and verifies the network, then confirms server deletion before sending the network and sanitized log to your bucket. If deletion is not confirmed, no save occurs. If bucket saving is not confirmed, the verified local candidate stays available to download or retry; the remote save may have completed. Each batch step saves before the next starts, and a failed save stops the batch.</p><button id="bucket_disconnect" type="button">Disconnect bucket and clear HF authorization</button><div class="toolbar"><button id="bucket_save" type="button" disabled>Save selected bundle</button><button id="bucket_refresh" type="button" disabled>Refresh saved bundles</button></div><label for="bucket_items">Saved bundles from this app</label><select id="bucket_items" size="4" disabled><option value="">Refresh to list saved bundles</option></select><button id="bucket_restore" type="button" disabled>Restore selected bundle</button><hr><h3 id="bucketRecipeTitle" tabindex="-1">Recipe library (settings only)</h3><p class="hint">Save and import the validated recipes and batch definitions from this browser. This 32 KB library contains settings only; networks, tracks, run results and access tokens are never included. Import asks before replacing the local recipe library and never starts a run.</p><div class="toolbar"><button id="bucket_recipe_save" type="button" disabled>Save recipe library</button><button id="bucket_recipe_refresh" type="button" disabled>Refresh saved recipe libraries</button></div><label for="bucket_recipe_items">Saved recipe libraries</label><select id="bucket_recipe_items" size="4" disabled><option value="">Refresh to list saved recipe libraries</option></select><button id="bucket_recipe_import" type="button" disabled>Import selected recipe library</button><p id="bucket_recipe_status" role="status" aria-live="polite">No recipe library bucket action requested.</p></div><p id="bucket_status" role="status" aria-live="polite">Not connected. Bucket storage is optional.</p></details></details>
 <p id="deadline"></p><p id="status" role="status">Ready. Inputs remain on this device until you run the test.</p>
-<details><summary>Effective training settings</summary><pre id="effectiveSettings"></pre></details><details><summary>Generation results</summary><pre id="generationHistory"></pre></details><details><summary>Star challenges — not evaluated</summary><p>The current runner has star-challenge reporting. Its evaluator and required statistics have not been ported to HF; no star result is inferred from a completed test.</p></details></section></div>
+<details><summary>Effective training settings</summary><pre id="effectiveSettings"></pre></details><details><summary>Generation results</summary><pre id="generationHistory"></pre></details><details><summary>About star challenge checks</summary><p>After a run, supported conditions are checked against its named policy with a bounded fresh replay. Results appear in the Star challenge check panel when available. These are predictions for the reconstructed replica track, not original-game awards; opponent races and unsupported conditions are left unchecked.</p></details></section></div>
 </div><section id="training" class="pane" hidden><div class="card"><h2>Training settings</h2><p class="hint">Choose the track on Drive & view. Choose the training settings and reward mix here, then start the run on Drive & view. Recipes and batch sequences are saved in this browser.</p><p><label for="trackPresetTraining">Training track</label><select id="trackPresetTraining" data-track-library disabled><option value="">Upload a custom track</option></select></p><p data-track-status role="status" class="hint">Loading built-in replica tracks…</p><div id="training_controls"><label for="training_ticks">Simulated ticks per generation</label><input id="training_ticks" type="number" min="1" max="18000" value="60"><small>60 ticks = one simulated second. Current preview limit: population × generations × ticks ≤ 4,000,000; execution timeout 25 seconds.</small>
 <div class="row"><div><label for="population">Population</label><input id="population" type="number" min="1" max="128" value="8" disabled><small>1–128 cars in this beta.</small></div><div><label for="generations">Generations</label><input id="generations" type="number" min="1" max="1000" value="30" disabled><small>1–1,000; try 20–50 before review.</small></div></div>
 <label id="mutation_label" for="mutation">Mutation rate</label><input id="mutation" type="number" min="0" max="4.2" step="0.01" value="0.1" disabled><small>Use a positive mutation rate, including when continuing an uploaded network. A one-generation run still evaluates the uploaded parent.</small>

native/analysis.patch

@@ -1,6 +1,6 @@
 --- a/src/bin/altd-sim/args.rs
 +++ b/src/bin/altd-sim/args.rs
-@@ -290,6 +290,15 @@
+@@ -290,6 +290,18 @@
          /// Export the final complete batch fitness leader before reproduction.
          #[arg(long)]
          save_final_candidate: bool,
@@ -10,6 +10,9 @@
 +        /// Evaluate the exact init-network once without initializing an optimizer population.
 +        #[arg(long, requires = "init_network")]
 +        evaluate_frozen: bool,
++        /// Observe every game statistics callback of a fresh fixed-policy evaluation.
++        #[arg(long, requires = "evaluate_frozen")]
++        challenge_observations: bool,
 +        /// Forward laps required for the zero-physical-contact winner.
 +        #[arg(long, default_value_t = 2)]
 +        clean_min_laps: u64,
@@ -18,27 +21,29 @@
          stop_score_above: Option<f64>,
 --- a/src/bin/altd-sim/main.rs
 +++ b/src/bin/altd-sim/main.rs
-@@ -161,6 +161,9 @@
+@@ -161,6 +161,10 @@
              batch_count,
              checkpoint_every,
              save_final_candidate,
 +            analysis,
 +            evaluate_frozen,
++            challenge_observations,
 +            clean_min_laps,
              resume,
              eliminate_on_wall,
              no_eliminate_on_wall,
-@@ -203,6 +206,9 @@
+@@ -203,6 +207,10 @@
                  batch_count,
                  checkpoint_every,
                  save_final_candidate,
 +                analysis,
 +                evaluate_frozen,
++                challenge_observations,
 +                clean_min_laps,
                  resume,
                  stop,
                  eliminate_on_wall: flag(eliminate_on_wall, no_eliminate_on_wall),
---- a/src/bin/altd-sim/scratch/analysis.rs
+--- /dev/null
 +++ b/src/bin/altd-sim/scratch/analysis.rs
 @@ -0,0 +1,253 @@
 +//! Read-only generation-boundary observations and immutable winner snapshots.
@@ -294,21 +299,83 @@
 +        assert!(better_lap(&row(2, 0, Some(9.0)), Some(&old)));
 +    }
 +}
+--- /dev/null
++++ b/src/bin/altd-sim/scratch/challenge.rs
+@@ -0,0 +1,57 @@
++//! Fresh-policy statistics callback telemetry only; no challenge predicates.
++use altd_sim::training::TrainingRunner;
++use serde_json::json;
++use std::{fs::File, io::{BufWriter, Write}, path::{Path, PathBuf}};
++
++pub(super) struct ChallengeObservations {
++    output: BufWriter<File>,
++    dir: PathBuf,
++    requested_ticks: u64,
++    lap_score: f64,
++    backend: &'static str,
++    frames: u64,
++}
++
++impl ChallengeObservations {
++    pub(super) fn new(dir: &Path, requested_ticks: u64, lap_score: f64, backend: &'static str) -> Self {
++        assert!(lap_score.is_finite() && lap_score > 0.0, "challenge observations require a positive native lap score");
++        Self { output: BufWriter::new(File::create(dir.join("challenge-observations.jsonl")).expect("create callback observations")),
++            dir: dir.to_owned(), requested_ticks, lap_score, backend, frames: 0 }
++    }
++
++    pub(super) fn sample(&mut self, runner: &TrainingRunner, callback_active: bool) {
++        assert_eq!(runner.agents.len(), 1);
++        assert_eq!(runner.tick % 6, 0);
++        let agent = &runner.agents[0];
++        let stats = &agent.stats;
++        // An active callback updates previous_speed before driving. An inactive
++        // terminal callback stops before driving and its car speed is exact.
++        let velocity = altd_sim::math::godot_math::F2::from(agent.car.velocity);
++        let speed = if callback_active { stats.previous_speed }
++            else { velocity.dot(velocity).sqrt() as f64 };
++        let row = json!({"tick":runner.tick, "game_time":((runner.tick - 6) / 6) as f64 * 0.1,
++            "stats_update_count":stats.update_count, "current_score":stats.score.total_score,
++            "current_best_score":stats.score.total_score, "worst_score":stats.score.total_score,
++            "went_backwards":stats.score.went_backwards, "forward_laps":stats.score.lap_count,
++            "drift_cumulative":stats.total_drifting_amount,
++            "continuous_drift_time":stats.continuous_drift_time,
++            "max_continuous_drift_time":stats.max_continuous_drift_time,
++            "speed_kph":speed / 15.0 * 3.6, "collision_count":stats.collision_count,
++            "active":callback_active, "best_lap_seconds":stats.best_lap_time});
++        serde_json::to_writer(&mut self.output, &row).expect("write callback observation");
++        self.output.write_all(b"\n").expect("write callback newline");
++        self.frames += 1;
++    }
++
++    pub(super) fn finish(mut self) {
++        self.output.flush().expect("flush all callback observations");
++        let meta = json!({"schema":"ald.challenge-observations", "version":1, "mode":"evaluate",
++            "lap_score":self.lap_score, "stats_interval_seconds":0.1, "first_stats_tick":6,
++            "requested_ticks":self.requested_ticks, "frames":self.frames, "execution_backend":self.backend,
++            "active_semantics":"after_statistics_before_drive",
++            "collision_semantics":"AgentStats collision update count, not physical contact count",
++            "score_semantics":"Signed path score; single-car current_best_score and worst_score equal current_score"});
++        std::fs::write(self.dir.join("challenge-observations-meta.json"), serde_json::to_vec(&meta).unwrap())
++            .expect("write callback metadata");
++    }
++}
 --- a/src/bin/altd-sim/scratch/mod.rs
 +++ b/src/bin/altd-sim/scratch/mod.rs
-@@ -1,5 +1,6 @@
+@@ -1,5 +1,7 @@
  //! Scratch training configuration, checkpoints, and stopping rules.
  
 +mod analysis;
++mod challenge;
  mod checkpoint;
  mod runner;
  mod stop;
-@@ -37,6 +38,9 @@
+@@ -37,6 +39,10 @@
      pub(super) batch_count: usize,
      pub(super) checkpoint_every: usize,
      pub(super) save_final_candidate: bool,
 +    pub(super) analysis: bool,
 +    pub(super) evaluate_frozen: bool,
++    pub(super) challenge_observations: bool,
 +    pub(super) clean_min_laps: u64,
      pub(super) stop: StopRules,
      pub(super) eliminate_on_wall: Option<bool>,
@@ -324,7 +391,7 @@
          "mutation rates must be positive"
      );
  
-@@ -110,6 +110,15 @@
+@@ -110,6 +110,19 @@
          .validate_algorithm()
          .unwrap_or_else(|e| panic!("settings: {e}"));
  
@@ -336,11 +403,15 @@
 +        !config.evaluate_frozen
 +            || (config.analysis && config.population == 1 && config.generations == 1 && config.checkpoint_every == 0),
 +        "frozen evaluation requires analysis, one exact policy, one generation, and no checkpoint turnover"
++    );
++    assert!(
++        !config.challenge_observations || (config.evaluate_frozen && config.ticks <= 18_000),
++        "challenge observations require a bounded fresh frozen evaluation"
 +    );
      let dir = &config.out_dir;
      let best_dir = dir.join("best_laps");
      std::fs::create_dir_all(&best_dir).unwrap_or_else(|e| panic!("{}: {e}", best_dir.display()));
-@@ -338,7 +347,11 @@
+@@ -338,7 +351,11 @@
          );
          generation as usize
      } else {
@@ -353,7 +424,7 @@
          std::fs::write(&log_path, "").expect("log file");
          0
      };
-@@ -370,6 +383,10 @@
+@@ -370,6 +387,14 @@
          started.elapsed().as_secs_f64()
      );
  
@@ -361,10 +432,41 @@
 +    let mut analysis = config
 +        .analysis
 +        .then(|| super::analysis::Analysis::new(dir, config.clean_min_laps, config.evaluate_frozen));
++    let mut challenge = config.challenge_observations.then(|| super::challenge::ChallengeObservations::new(
++        dir, config.ticks, runner.world.track.path_length() * (5.0 / 384.0),
++        if gpu_sim.is_some() { "cuda" } else { "cpu" },
++    ));
      let fmt_lap = |lap: Option<f64>| lap.map_or("   -   ".to_string(), |t| format!("{t:7.2}"));
      let mut stop_state = StopState {
          best_lap: None,
-@@ -493,6 +510,18 @@
+@@ -422,12 +447,22 @@
+             let track_config = current_track.as_ref().map(|track| track.track.config.clone());
+             match (&mut gpu_sim, &gpu_world) {
+                 (Some(sim), Some(world)) => {
+-                    runner
+-                        .advance_generation_gpu(sim, world, config.ticks)
+-                        .unwrap_or_else(|e| panic!("--gpu: {e}"));
++                    if let Some(observer) = &mut challenge {
++                        runner.advance_generation_gpu_observed(sim, world, config.ticks,
++                            |runner, active| observer.sample(runner, active))
++                            .unwrap_or_else(|e| panic!("--gpu: {e}"));
++                    } else {
++                        runner.advance_generation_gpu(sim, world, config.ticks)
++                            .unwrap_or_else(|e| panic!("--gpu: {e}"));
++                    }
+                 }
+                 _ => {
+-                    runner.advance_generation(config.ticks);
++                    if let Some(observer) = &mut challenge {
++                        runner.advance_generation_observed(config.ticks,
++                            |runner, active| observer.sample(runner, active));
++                    } else {
++                        runner.advance_generation(config.ticks);
++                    }
+                 }
+             }
+             simulated_ticks += runner.tick;
+@@ -493,6 +528,18 @@
          }
          let simulate_seconds = generation_started.elapsed().as_secs_f64();
          let summary = batch.finish();
@@ -383,7 +485,7 @@
          let best_score = summary.mean_scores.iter().copied().fold(f64::NEG_INFINITY, f64::max);
          let mean_score = py_sum(summary.mean_scores.iter().copied()) / config.population as f64;
          let mean_lap = (lap_count > 0).then(|| lap_time_sum / lap_count as f64);
-@@ -521,7 +550,7 @@
+@@ -521,7 +568,7 @@
          }
          let last = stop_reason.is_some();
          let final_checkpoint = last && config.checkpoint_every > 0;
@@ -392,17 +494,20 @@
              let leader = final_candidate_leader(&summary.fitness);
              let mut export = runner.agents[leader].network.to_json();
              export["schema_version"] = json!(1);
-@@ -606,6 +635,9 @@
+@@ -606,6 +653,12 @@
              break;
          }
      }
 +    if let Some(writer) = analysis {
 +        writer.finish();
++    }
++    if let Some(writer) = challenge {
++        writer.finish();
 +    }
      let _ = std::fs::remove_file(dir.join("progress.json"));
      println!(
          "done: best lap {} (generation {}), {:.1} h",
-@@ -614,3 +646,7 @@
+@@ -614,3 +667,7 @@
          started.elapsed().as_secs_f64() / 3600.0
      );
  }
@@ -455,9 +560,126 @@
  }
  
  /// The adaptive mutation scale; its log is the C runtime's (.NET Math.Log).
---- a/tests/winner_analysis.rs
+--- a/src/training/runner/gpu.rs
++++ b/src/training/runner/gpu.rs
+@@ -96,6 +96,37 @@
+     ) -> Result<u64, String> {
+         let (ticks, time_limit) = self.gpu_generation_window(time_limit_ticks)?;
+         self.advance_window_gpu(sim, world, ticks, true, Some(time_limit))
++    }
++
++    /// Observe every existing statistics callback while keeping device state
++    /// resident. Readback is observation only; never re-upload rounded host state.
++    #[cfg(not(target_arch = "wasm32"))]
++    pub fn advance_generation_gpu_observed<F>(
++        &mut self,
++        sim: &mut crate::gpu::simulation::GpuSim,
++        world: &crate::gpu::hip::GpuWorld,
++        time_limit_ticks: u64,
++        mut observe: F,
++    ) -> Result<u64, String>
++    where F: FnMut(&Self, bool) {
++        assert_eq!(self.agents.len(), 1, "callback observations require one fixed policy");
++        let start = self.tick;
++        let (remaining, limit) = self.gpu_generation_window(time_limit_ticks)?;
++        let end = start + remaining;
++        self.upload_state_gpu(sim, world)?;
++        while self.tick < end {
++            let previous_updates = self.agents[0].stats.update_count;
++            let count = (6 - self.tick % 6).min(end - self.tick);
++            let executed = self.window_gpu(sim, count, true, Some(limit))?;
++            self.download_state_gpu(sim, world)?;
++            if self.tick % 6 == 0 {
++                let callback_active = self.statistics_callback_active(previous_updates);
++                observe(self, callback_active);
++                if !callback_active || ((self.tick - 6) / 6) as f64 * 0.1 >= limit { break; }
++            }
++            if executed == 0 { break; }
++        }
++        Ok(self.tick - start)
+     }
+ 
+     /// The window length and time limit (seconds) of `advance_generation_gpu`.
+--- a/src/training/runner/schedule.rs
++++ b/src/training/runner/schedule.rs
+@@ -112,6 +112,37 @@
+     pub fn advance_generation(&mut self, time_limit_ticks: u64) -> u64 {
+         let (ticks, time_limit) = self.generation_window(time_limit_ticks);
+         self.advance_window(ticks, true, Some(time_limit))
++    }
++
++    /// Observe one fixed-policy car at each existing statistics callback.
++    /// Windows retain the absolute physics and inference cursors. No optimizer runs.
++    pub fn advance_generation_observed<F>(&mut self, time_limit_ticks: u64, mut observe: F) -> u64
++    where F: FnMut(&Self, bool) {
++        assert_eq!(self.agents.len(), 1, "callback observations require one fixed policy");
++        assert!(!self.user_paused, "callback observations require an unpaused evaluation");
++        let start = self.tick;
++        let (remaining, limit) = self.generation_window(time_limit_ticks);
++        let end = start + remaining;
++        while self.tick < end {
++            let previous_updates = self.agents[0].stats.update_count;
++            let count = (6 - self.tick % 6).min(end - self.tick);
++            let executed = self.advance_window(count, true, Some(limit));
++            if self.tick % 6 == 0 {
++                let callback_active = self.statistics_callback_active(previous_updates);
++                observe(self, callback_active);
++                if !callback_active || ((self.tick - 6) / 6) as f64 * 0.1 >= limit { break; }
++            }
++            if executed == 0 { break; }
++        }
++        self.tick - start
++    }
++
++    /// Stats precede driving. A drive-step wall contact may already have changed
++    /// car.active at readback; the update counter and idle rule recover the
++    /// callback's actual post-statistics/pre-drive state without altering it.
++    pub fn statistics_callback_active(&self, previous_updates: u64) -> bool {
++        let stats = &self.agents[0].stats;
++        stats.update_count > previous_updates && !(self.eliminate_when_idle && stats.idle_ticks > 80)
+     }
+ 
+     /// The remaining window of a generation with `time_limit_ticks`: the tick
+--- a/src/training/runner/tests.rs
++++ b/src/training/runner/tests.rs
+@@ -382,3 +382,34 @@
+         );
+     }
+ }
++
++
++#[test]
++fn challenge_callbacks_preserve_idle_and_inactive_cutoffs() {
++    let seed = Network::from_vector(&[20, 5], vec![0.0; 105]);
++    for inactive in [false, true] {
++        let mut plain = generated_runner(1);
++        let mut observed = generated_runner(1);
++        plain.resume(&[seed.clone()], 0);
++        observed.resume(&[seed.clone()], 0);
++        if inactive {
++            plain.agents[0].car.deactivate();
++            observed.agents[0].car.deactivate();
++        } else {
++            plain.agents[0].stats.idle_ticks = 79;
++            observed.agents[0].stats.idle_ticks = 79;
++        }
++        let expected = plain.advance_generation(600);
++        let mut frames = Vec::new();
++        let actual = observed.advance_generation_observed(600, |runner, active| {
++            frames.push((runner.tick, active, runner.agents[0].stats.update_count));
++        });
++        assert_eq!(expected, actual, "callback mode must stop at the same pre-drive frame");
++        assert_same_agents(&plain, &observed);
++        if inactive {
++            assert_eq!(frames, vec![(6, false, 0)]);
++        } else {
++            assert_eq!(frames, vec![(6, true, 1), (12, false, 2)]);
++        }
++    }
++}
+--- /dev/null
 +++ b/tests/winner_analysis.rs
-@@ -0,0 +1,147 @@
+@@ -0,0 +1,179 @@
 +//! Native boundary checks: observations preserve evolution and frozen policies.
 +use altd_sim::nn::network::Network;
 +use serde_json::{json, Value};
@@ -536,6 +758,38 @@
 +    }
 +    root
 +}
++
++#[test]
++fn challenge_callbacks_preserve_frozen_schedule_and_capture_every_statistics_update() {
++    let root = workspace("challenge-callbacks");
++    run(&root, "plain", &["--analysis", "--evaluate-frozen"]);
++    run(&root, "observed", &["--analysis", "--evaluate-frozen", "--challenge-observations"]);
++    let plain = fs::read(root.join("plain/analysis/descriptors.jsonl")).unwrap();
++    let observed = fs::read(root.join("observed/analysis/descriptors.jsonl")).unwrap();
++    assert_eq!(plain, observed, "callback readback must not alter any final physical/statistical measurement or weights");
++    let rows: Vec<Value> = fs::read_to_string(root.join("observed/challenge-observations.jsonl"))
++        .unwrap().lines().map(|line| serde_json::from_str(line).unwrap()).collect();
++    assert_eq!(rows.len(), 11, "60 requested ticks use callbacks 6 through 66 inclusive");
++    let final_row: Value = serde_json::from_slice(&observed).unwrap();
++    for (index, row) in rows.iter().enumerate() {
++        assert_eq!(row["tick"], (index + 1) * 6);
++        assert_eq!(row["game_time"].as_f64().unwrap(), index as f64 * 0.1);
++        assert_eq!(row["stats_update_count"], index + 1);
++        assert_eq!(row["current_score"], row["worst_score"]);
++        assert_eq!(row["current_score"], row["current_best_score"]);
++        assert_eq!(row["active"], true);
++        assert!(row["speed_kph"].as_f64().unwrap().is_finite());
++    }
++    let speed_sum: f64 = rows.iter().map(|row| row["speed_kph"].as_f64().unwrap() / 3.6 * 15.0).sum();
++    assert!((speed_sum - final_row["raw_metrics"]["total_speed"].as_f64().unwrap()).abs() < 1e-8,
++        "every speed sample must describe the statistics callback, not its following drive step");
++    assert_eq!(rows.last().unwrap()["current_score"], final_row["raw_metrics"]["total_score"]);
++    assert_eq!(rows.last().unwrap()["collision_count"], final_row["objectives"]["collision_updates"]);
++    let meta = load(root.join("observed/challenge-observations-meta.json"));
++    assert_eq!(meta["frames"], rows.len());
++    assert!(meta["lap_score"].as_f64().unwrap() > 0.0);
++    fs::remove_dir_all(root).unwrap();
++}
 +#[test]
 +fn observation_is_rng_neutral_and_final_winner_matches_exact_pre_turnover_parameters() {
 +    let root = workspace("neutral");

native/build-receipt.json

@@ -1,89 +1 @@
-{
-  "schema": "ald-winners-linux-build-v1",
-  "status": "passed",
-  "created_utc": "2026-10-14T04:35:53.223545+00:00",
-  "source": {
-    "upstream_revision": "b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0",
-    "source_receipt_sha256": "33d09c326e4d6c3ac1d1839e4528c70c06b4ff48138b90f174f434ab685b4b34",
-    "patch_sha256": "56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63",
-    "source_inventory_sha256": "3311905f217e08a927ca73d71db6687aaaf68f01cc2758e4028b92fa703bcebe"
-  },
-  "artifacts": {
-    "cpu/bin/altd-sim": {
-      "path": "cpu/bin/altd-sim",
-      "bytes": 3580296,
-      "sha256": "6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d",
-      "origin_type": "local_linux_build"
-    },
-    "gpu/bin/altd-sim": {
-      "path": "gpu/bin/altd-sim",
-      "bytes": 3580296,
-      "sha256": "6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d",
-      "origin_type": "local_linux_build"
-    },
-    "gpu/bin/libaltd_gpu.so": {
-      "path": "gpu/bin/libaltd_gpu.so",
-      "bytes": 4711704,
-      "sha256": "3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca",
-      "origin_type": "retained_cuda_b90"
-    }
-  },
-  "checks": {
-    "native_tests": {
-      "status": "passed",
-      "receipt_path": "build/receipts/linux-native-tests.json",
-      "receipt_sha256": "ddb35821b16094bc0da624748e1f07e0b7a06cea4d4bc9baa28a7b6356bfacdb"
-    },
-    "cpu_smoke": {
-      "status": "passed",
-      "receipt_path": "build/receipts/linux-cpu-smoke.json",
-      "receipt_sha256": "afb4107c84bb38f21b9fabd6bbd9401b236ebff16ae2ce23230640994b8fd85c"
-    },
-    "gpu_layout": {
-      "status": "passed",
-      "receipt_path": "build/receipts/linux-gpu-layout.json",
-      "receipt_sha256": "45462cb6f4047e7715d6258fea60b9b39b1f8ea2e88ebbe3479454d53801cc00"
-    }
-  },
-  "gpu_device_execution": "not_run",
-  "compiler": {
-    "version": "rustc 1.95.0 (59807616e 2026-04-14)",
-    "host": "aarch64-apple-darwin",
-    "target": "x86_64-unknown-linux-gnu",
-    "cross_compiled": true,
-    "standard_library": {
-      "origin": "official_rust_distribution",
-      "url": "https://static.rust-lang.org/dist/2026-04-16/rust-std-1.95.0-x86_64-unknown-linux-gnu.tar.xz",
-      "sha256": "047ea7098803d3500fa1072e9cee5392697e21525559e4458128a2bf874aa382",
-      "installed_manifest_sha256": "46c1f8d1bcef24174217545ece8c22eb395a42e3534f618736c17a759a31e255"
-    },
-    "linker": {
-      "clang_version": "Apple clang version 21.0.0 (clang-2100.3.34.2)",
-      "lld_origin": "installed Rust1.95 bundled rust-lld",
-      "wrapper_path": "build/cross-tools/linux-linker",
-      "wrapper_sha256": "53fcd6801c00d79b669c231841079988a285e583142e59b1cdf29f8c19b1fc5f"
-    },
-    "sysroot": {
-      "origin": "read-only Ubuntu22.04 libraries copied from our existing nvidia/cuda:13.0.2-devel-ubuntu22.04 container",
-      "inventory_path": "build/receipts/linux-sysroot-inventory.json",
-      "inventory_sha256": "a4a9d33b5ec227a18b7f76f2df085fba372c5b6acd827cf28de84867df53ba6f"
-    }
-  },
-  "build_command": "/Users/tiga/.cargo/bin/cargo +1.95.0 build --target x86_64-unknown-linux-gnu --manifest-path build/source/Cargo.toml --release --locked --offline --no-default-features --features cli --bin altd-sim",
-  "build_environment": {
-    "CARGO_TARGET_DIR": "/Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-target",
-    "CARGO_PROFILE_RELEASE_LTO": "false",
-    "CARGO_PROFILE_RELEASE_CODEGEN_UNITS": "16",
-    "CARGO_PROFILE_RELEASE_DEBUG": "0",
-    "CARGO_BUILD_JOBS": "4",
-    "CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER": "/Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-tools/linux-linker",
-    "RUSTFLAGS": "--sysroot /Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-sysroot -C target-cpu=x86-64"
-  },
-  "build_recipe_path": "build/recipes/native-cross-build.py",
-  "build_recipe_sha256": "17c731594d158bbc6627340954c1b2c53e90232fe2f89b48c2c33d73ae56fcc4",
-  "build_log_path": "build/receipts/native-cross-build.log",
-  "build_log_sha256": "d201fa42f1e379210dd385d394207e4afccb2d837e281ee86f6b4d992aa087f8",
-  "source_preserved": true,
-  "installed_toolchain_unchanged": true,
-  "original_baseline_binaries_unchanged": true
-}
+{"artifact":{"bytes":3604272,"path":"build/artifacts/altd-sim-stars","sha256":"3aa1d364e0117f553a52404ae336efcfebd827fc0ca347e811196cbe31e32849"},"artifacts":{"cpu/bin/altd-sim":{"bytes":3604272,"origin_type":"local_linux_build","path":"build/artifacts/altd-sim-stars","sha256":"3aa1d364e0117f553a52404ae336efcfebd827fc0ca347e811196cbe31e32849"},"gpu/bin/altd-sim":{"bytes":3604272,"origin_type":"local_linux_build","path":"build/artifacts/altd-sim-stars","sha256":"3aa1d364e0117f553a52404ae336efcfebd827fc0ca347e811196cbe31e32849"},"gpu/bin/libaltd_gpu.so":{"bytes":4711704,"origin_type":"retained_cuda_b90","path":"gpu/bin/libaltd_gpu.so","sha256":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca"}},"based_on_build_receipt_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","baseline_build_evidence":{"artifacts":{"cpu/bin/altd-sim":{"bytes":3580296,"origin_type":"local_linux_build","path":"cpu/bin/altd-sim","sha256":"6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d"},"gpu/bin/altd-sim":{"bytes":3580296,"origin_type":"local_linux_build","path":"gpu/bin/altd-sim","sha256":"6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d"},"gpu/bin/libaltd_gpu.so":{"bytes":4711704,"origin_type":"retained_cuda_b90","path":"gpu/bin/libaltd_gpu.so","sha256":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca"}},"build_command":"/Users/tiga/.cargo/bin/cargo +1.95.0 build --target x86_64-unknown-linux-gnu --manifest-path build/source/Cargo.toml --release --locked --offline --no-default-features --features cli --bin altd-sim","build_environment":{"CARGO_BUILD_JOBS":"4","CARGO_PROFILE_RELEASE_CODEGEN_UNITS":"16","CARGO_PROFILE_RELEASE_DEBUG":"0","CARGO_PROFILE_RELEASE_LTO":"false","CARGO_TARGET_DIR":"/Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-target","CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER":"/Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-tools/linux-linker","RUSTFLAGS":"--sysroot /Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-sysroot -C target-cpu=x86-64"},"build_log_path":"build/receipts/native-cross-build.log","build_log_sha256":"d201fa42f1e379210dd385d394207e4afccb2d837e281ee86f6b4d992aa087f8","build_recipe_path":"build/recipes/native-cross-build.py","build_recipe_sha256":"17c731594d158bbc6627340954c1b2c53e90232fe2f89b48c2c33d73ae56fcc4","checks":{"cpu_smoke":{"receipt_path":"build/receipts/linux-cpu-smoke.json","receipt_sha256":"afb4107c84bb38f21b9fabd6bbd9401b236ebff16ae2ce23230640994b8fd85c","status":"passed"},"gpu_layout":{"receipt_path":"build/receipts/linux-gpu-layout.json","receipt_sha256":"45462cb6f4047e7715d6258fea60b9b39b1f8ea2e88ebbe3479454d53801cc00","status":"passed"},"native_tests":{"receipt_path":"build/receipts/linux-native-tests.json","receipt_sha256":"ddb35821b16094bc0da624748e1f07e0b7a06cea4d4bc9baa28a7b6356bfacdb","status":"passed"}},"compiler":{"cross_compiled":true,"host":"aarch64-apple-darwin","linker":{"clang_version":"Apple clang version 21.0.0 (clang-2100.3.34.2)","lld_origin":"installed Rust1.95 bundled rust-lld","wrapper_path":"build/cross-tools/linux-linker","wrapper_sha256":"53fcd6801c00d79b669c231841079988a285e583142e59b1cdf29f8c19b1fc5f"},"standard_library":{"installed_manifest_sha256":"46c1f8d1bcef24174217545ece8c22eb395a42e3534f618736c17a759a31e255","origin":"official_rust_distribution","sha256":"047ea7098803d3500fa1072e9cee5392697e21525559e4458128a2bf874aa382","url":"https://static.rust-lang.org/dist/2026-04-16/rust-std-1.95.0-x86_64-unknown-linux-gnu.tar.xz"},"sysroot":{"inventory_path":"build/receipts/linux-sysroot-inventory.json","inventory_sha256":"a4a9d33b5ec227a18b7f76f2df085fba372c5b6acd827cf28de84867df53ba6f","origin":"read-only Ubuntu22.04 libraries copied from our existing nvidia/cuda:13.0.2-devel-ubuntu22.04 container"},"target":"x86_64-unknown-linux-gnu","version":"rustc 1.95.0 (59807616e 2026-04-14)"},"created_utc":"2026-10-14T04:35:53.223545+00:00","gpu_device_execution":"not_run","installed_toolchain_unchanged":true,"original_baseline_binaries_unchanged":true,"schema":"ald-winners-linux-build-v1","source":{"patch_sha256":"56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63","source_inventory_sha256":"3311905f217e08a927ca73d71db6687aaaf68f01cc2758e4028b92fa703bcebe","source_receipt_sha256":"33d09c326e4d6c3ac1d1839e4528c70c06b4ff48138b90f174f434ab685b4b34","upstream_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"},"source_preserved":true,"status":"passed"},"baseline_build_evidence_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","build_log_sha256":"ef5114e8176eac9e23105c3d9bd0f1689edbb0e0e798171df6a56094851a93d1","callback_runtime_evidence":{"binary_sha256":"3aa1d364e0117f553a52404ae336efcfebd827fc0ca347e811196cbe31e32849","callbacks":{"observed":{"descriptors_sha256":"9533425b75286e6d3bc08f31bd375da048825294ea40e40f82dba36868339714","log_path":"build/receipts/star-linux-observed.log","log_sha256":"33572e0fb5dce3daa5ba8bc3ab5779585e3a76e4b489c4a04c1e9422dc076742"},"plain":{"descriptors_sha256":"9533425b75286e6d3bc08f31bd375da048825294ea40e40f82dba36868339714","log_path":"build/receipts/star-linux-plain.log","log_sha256":"f8843fd74b9a528c42c1677dfe98cceeece050e1e17b566c82b69fac98a8caf2"}},"cpu_frames":11,"cpu_observer_neutrality":true,"cpu_vehicle_type":2,"gpu_device_execution":"not_run","gpu_layout":{"device":null,"library_sha256":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca","log_path":"build/receipts/star-linux-gpu-info.txt","log_sha256":"87dd7d86457a64e623ae15a29a97fe45d9f5610d4e68eb4cd0bd52b5d8147e3b","status":"passed"},"schema":"ald-star-linux-runtime-v1","status":"passed","test_harness_note":"Initial human-text layout assertion failed on valid JSON output; corrected by parsing existing output, no repeat runtime call."},"command":["/Users/tiga/.cargo/bin/cargo","+1.95.0","build","--target","x86_64-unknown-linux-gnu","--manifest-path","build/source/Cargo.toml","--release","--locked","--offline","--no-default-features","--features","cli","--bin","altd-sim"],"compiler":{"cross_compiled":true,"host":"aarch64-apple-darwin","linker":{"clang_version":"Apple clang version 21.0.0 (clang-2100.3.34.2)","lld_origin":"installed Rust1.95 bundled rust-lld","wrapper_path":"build/cross-tools/linux-linker","wrapper_sha256":"53fcd6801c00d79b669c231841079988a285e583142e59b1cdf29f8c19b1fc5f"},"standard_library":{"installed_manifest_sha256":"46c1f8d1bcef24174217545ece8c22eb395a42e3534f618736c17a759a31e255","origin":"official_rust_distribution","sha256":"047ea7098803d3500fa1072e9cee5392697e21525559e4458128a2bf874aa382","url":"https://static.rust-lang.org/dist/2026-04-16/rust-std-1.95.0-x86_64-unknown-linux-gnu.tar.xz"},"sysroot":{"inventory_path":"build/receipts/linux-sysroot-inventory.json","inventory_sha256":"a4a9d33b5ec227a18b7f76f2df085fba372c5b6acd827cf28de84867df53ba6f","origin":"read-only Ubuntu22.04 libraries copied from our existing nvidia/cuda:13.0.2-devel-ubuntu22.04 container"},"target":"x86_64-unknown-linux-gnu","version":"rustc 1.95.0 (59807616e 2026-04-14)"},"device_execution":"not_run","elapsed_seconds":20.25416398048401,"environment":{"CARGO_BUILD_JOBS":"4","CARGO_PROFILE_RELEASE_CODEGEN_UNITS":"16","CARGO_PROFILE_RELEASE_DEBUG":"0","CARGO_PROFILE_RELEASE_LTO":"false","CARGO_TARGET_DIR":"/Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-target","CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER":"/Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-tools/linux-linker","RUSTFLAGS":"--sysroot /Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-sysroot -C target-cpu=x86-64"},"evidence_ceiling":"Mac callback tests and Linux CPU observer-neutral smoke; CUDA layout only, device observation not run","exit_code":0,"gpu_device_execution":"not_run","runtime_receipt_path":"build/receipts/star-linux-runtime-receipt.json","runtime_receipt_sha256":"d19f5045d769e68458d6b4f4599981f3ffdda1baa28052ca4dde15513f880c04","schema":"ald-star-observer-linux-build-v1","source":{"patch_sha256":"42f79de67cb0734cffb2a7582f5479cab42ab82675884b8b42b9f158d46a98e8","source_inventory_sha256":"b65738094ba8b06513586348f60b8a93f8bdba280774ca96c18fac5401e66c8a","source_receipt_sha256":"36feba861501baf8672884476bbeed5e375254cbb4feffb9f4f90aa61a415a93","upstream_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"},"source_receipt_path":"build/receipts/star-source-receipt.json","source_receipt_sha256":"dbe7c216a3b4bb581ff6384a1a0db228542237f7e7a1c66e259e9f3f1d570959","star_delta_source_evidence":{"based_on_source_receipt_sha256":"33d09c326e4d6c3ac1d1839e4528c70c06b4ff48138b90f174f434ab685b4b34","changed_source_files":[{"baseline_sha256":"7e94398fdae67500735a7be1ba6de6c576ed021d9c96011fd20ef0a3f3d3f3d7","path":"src/bin/altd-sim/args.rs","sha256":"877157de1e635235c12bd5f2645c6856bdb01b119d433ff0a987767a302e2490"},{"baseline_sha256":"3e679871a0978b2d68ce7cbb520584f1951adc8a0b584145966e58b6ca20e933","path":"src/bin/altd-sim/main.rs","sha256":"2b3d88f6ff030fa9b5f006f679e04345e951b20dd824889976cc5c29546eb33e"},{"baseline_sha256":"1edaa2580112e4d0645743ab14bba16cf780d75800cd1036bd19f940bfc36680","path":"src/bin/altd-sim/scratch/mod.rs","sha256":"615bb5b05513bb8425dafc96aad50ac5dd9c1384ee89b9d099b8439a3916463f"},{"baseline_sha256":"0cab956fb0d63a20d6b62e01aadeb3d6592f4f12d601df095f41840a89329c55","path":"src/bin/altd-sim/scratch/runner.rs","sha256":"776c677d1de4f3416485a82c24ee64a414a5a165c30ee5b353f80f1e875f8a7c"},{"baseline_sha256":"12475cb92731f5e9c311a9ca62c4e17f0dfde17bc46efe9f827f6ba4a91ebbac","path":"src/training/runner/gpu.rs","sha256":"0588cd4487729707ac19b8294a20b9f44dd505005842f54e7a12b21b7c48ece3"},{"baseline_sha256":"7bae3c881f2f2b086f1007734008056fcedab3316626cd9a5b13909daec02890","path":"src/training/runner/schedule.rs","sha256":"9021bd9c70024eaa205f8c75219dded02ce7b5c3ac8f2cf064abdf41f47db65c"},{"baseline_sha256":"26fe931db6894bd72813136daf77fe0991307d1d715ffceea5f0e398e3e05b86","path":"src/training/runner/tests.rs","sha256":"c20b5d235aeee573479ae29dfdb1df0cab07d44148fa6d49aa96e84942b49e5d"},{"baseline_sha256":"df3afd6faca830679afbefa4520b6947126bc972895df76504df6d42362ede28","path":"tests/winner_analysis.rs","sha256":"8f6915059e02ff9935faefbd6e876283fc7c60bb4a5384385433a4e7e7fc6624"},{"baseline_sha256":null,"path":"src/bin/altd-sim/scratch/challenge.rs","sha256":"7d612882684a767bb1fdc8333bc1c407e2e1b8059493837eeef0c9843c447d01"}],"cuda_kernel_and_abi_changed":false,"cuda_kernel_and_abi_checks":{"all_match_b90":true,"source_members":25},"gpu_device_execution":"not_run","mac_binary":{"path":"build/mac-target/debug/altd-sim","sha256":"793eedfff6d3a355378120767c562409dcf27de75a56f174296f1f79d82d051d"},"mac_tests":{"binary_unit":8,"evidence_sha256":{"build/receipts/star-mac-cutoff-tests.log":"8bd7668cba009c80a8fb20de45108c4df56a49d8430a7d91fb7f22f42ae920d9","build/receipts/star-mac-tests-final.log":"4698b5af2b7a7b042bf0c485ca33568a474bcc47477d34b57b425659db3c1d58"},"integration":3,"library_cutoff":1,"paths":["build/receipts/star-mac-tests-final.log","build/receipts/star-mac-cutoff-tests.log"],"status":"passed"},"ordinary_training_changed":false,"patch_path":"build/receipts/star-native.patch","patch_sha256":"b37ea9586f3e1915153bd85b6c5c7fc70d025fba684db158914ff1137e08d3dd","schema":"ald-star-source-v1","source_inventory_sha256":"b65738094ba8b06513586348f60b8a93f8bdba280774ca96c18fac5401e66c8a","upstream_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"},"status":"passed"}

native/source-receipt.json

@@ -1,50 +1 @@
-{
-  "schema": "ald-native-analysis-source-v1",
-  "upstream_revision": "b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0",
-  "source_inventory_sha256": "3311905f217e08a927ca73d71db6687aaaf68f01cc2758e4028b92fa703bcebe",
-  "patch_sha256": "56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63",
-  "changed_source_files": [
-    {
-      "path": "src/bin/altd-sim/args.rs",
-      "baseline_sha256": "9f833f026d1f71ef76fe05d948464c619c76c15e43cedc11b5f510bfc337bda2",
-      "sha256": "7e94398fdae67500735a7be1ba6de6c576ed021d9c96011fd20ef0a3f3d3f3d7"
-    },
-    {
-      "path": "src/bin/altd-sim/main.rs",
-      "baseline_sha256": "841956a5a1a927b1a31369ccbd9aa18161b6328745a5a3ca4f02bdcfedd7230c",
-      "sha256": "3e679871a0978b2d68ce7cbb520584f1951adc8a0b584145966e58b6ca20e933"
-    },
-    {
-      "path": "src/bin/altd-sim/scratch/analysis.rs",
-      "baseline_sha256": null,
-      "sha256": "294c5c738de7fd573a3f3b89e4bdc8b35ba1c992b00959caa0bc75f19e41c3ba"
-    },
-    {
-      "path": "src/bin/altd-sim/scratch/mod.rs",
-      "baseline_sha256": "524e9033a1fb29ac7b4d689a21fede12b7bb77a772c078fce4c0bf4763568bbe",
-      "sha256": "1edaa2580112e4d0645743ab14bba16cf780d75800cd1036bd19f940bfc36680"
-    },
-    {
-      "path": "src/bin/altd-sim/scratch/runner.rs",
-      "baseline_sha256": "20a78bd99dc6bd69cc9314ba2d531dac13b5d9f21fb6ca676d34c0fa472a46c0",
-      "sha256": "0cab956fb0d63a20d6b62e01aadeb3d6592f4f12d601df095f41840a89329c55"
-    },
-    {
-      "path": "src/training/evolution.rs",
-      "baseline_sha256": "d050036c9346561411feefc6c94d598cb0f3ee69e85a8960cf911d60b2129a61",
-      "sha256": "488729530a2562295b44835716c7a4e055543614d0f262da682712cdac084460"
-    },
-    {
-      "path": "tests/winner_analysis.rs",
-      "baseline_sha256": null,
-      "sha256": "df3afd6faca830679afbefa4520b6947126bc972895df76504df6d42362ede28"
-    }
-  ],
-  "gpu_abi_source_unchanged": true,
-  "physics_source_unchanged": true,
-  "retained_cuda_library_sha256": "3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca",
-  "local_patch_semantics": "Host-only observations; unchanged simulation/evolution kernels. Descriptor helper reads native rewards without RNG; scratch frozen path resumes exact single policy and disables checkpoint turnover. Training state may be reused; evaluation uses fresh physical state.",
-  "mac_compiler": "rustc 1.95.0 (59807616e 2026-04-14)",
-  "mac_build_command": "cargo +1.95.0 --locked --offline --no-default-features --features cli; separate build/mac-target",
-  "linux_status": "passed"
-}
+{"changed_source_files":[{"baseline_sha256":"9f833f026d1f71ef76fe05d948464c619c76c15e43cedc11b5f510bfc337bda2","path":"src/bin/altd-sim/args.rs","sha256":"877157de1e635235c12bd5f2645c6856bdb01b119d433ff0a987767a302e2490"},{"baseline_sha256":"841956a5a1a927b1a31369ccbd9aa18161b6328745a5a3ca4f02bdcfedd7230c","path":"src/bin/altd-sim/main.rs","sha256":"2b3d88f6ff030fa9b5f006f679e04345e951b20dd824889976cc5c29546eb33e"},{"baseline_sha256":null,"path":"src/bin/altd-sim/scratch/analysis.rs","sha256":"294c5c738de7fd573a3f3b89e4bdc8b35ba1c992b00959caa0bc75f19e41c3ba"},{"baseline_sha256":null,"path":"src/bin/altd-sim/scratch/challenge.rs","sha256":"7d612882684a767bb1fdc8333bc1c407e2e1b8059493837eeef0c9843c447d01"},{"baseline_sha256":"524e9033a1fb29ac7b4d689a21fede12b7bb77a772c078fce4c0bf4763568bbe","path":"src/bin/altd-sim/scratch/mod.rs","sha256":"615bb5b05513bb8425dafc96aad50ac5dd9c1384ee89b9d099b8439a3916463f"},{"baseline_sha256":"20a78bd99dc6bd69cc9314ba2d531dac13b5d9f21fb6ca676d34c0fa472a46c0","path":"src/bin/altd-sim/scratch/runner.rs","sha256":"776c677d1de4f3416485a82c24ee64a414a5a165c30ee5b353f80f1e875f8a7c"},{"baseline_sha256":"d050036c9346561411feefc6c94d598cb0f3ee69e85a8960cf911d60b2129a61","path":"src/training/evolution.rs","sha256":"488729530a2562295b44835716c7a4e055543614d0f262da682712cdac084460"},{"baseline_sha256":"12475cb92731f5e9c311a9ca62c4e17f0dfde17bc46efe9f827f6ba4a91ebbac","path":"src/training/runner/gpu.rs","sha256":"0588cd4487729707ac19b8294a20b9f44dd505005842f54e7a12b21b7c48ece3"},{"baseline_sha256":"7bae3c881f2f2b086f1007734008056fcedab3316626cd9a5b13909daec02890","path":"src/training/runner/schedule.rs","sha256":"9021bd9c70024eaa205f8c75219dded02ce7b5c3ac8f2cf064abdf41f47db65c"},{"baseline_sha256":"26fe931db6894bd72813136daf77fe0991307d1d715ffceea5f0e398e3e05b86","path":"src/training/runner/tests.rs","sha256":"c20b5d235aeee573479ae29dfdb1df0cab07d44148fa6d49aa96e84942b49e5d"},{"baseline_sha256":null,"path":"tests/winner_analysis.rs","sha256":"8f6915059e02ff9935faefbd6e876283fc7c60bb4a5384385433a4e7e7fc6624"}],"cuda_kernel_and_abi_changed":false,"linux_status":"passed","patch_sha256":"42f79de67cb0734cffb2a7582f5479cab42ab82675884b8b42b9f158d46a98e8","schema":"ald-native-analysis-source-v1","scope":"b90 plus winners/frozen analysis and fixed-policy statistics callback observation","source_inventory_sha256":"b65738094ba8b06513586348f60b8a93f8bdba280774ca96c18fac5401e66c8a","star_delta_receipt_sha256":"dbe7c216a3b4bb581ff6384a1a0db228542237f7e7a1c66e259e9f3f1d570959","upstream_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"}

portable_bundle.py

@@ -24,7 +24,7 @@ MAX_DESCRIPTOR_ROWS = 128000
 ANALYSIS_JSON_LIMIT = 512 * 1024
 ANALYSIS_WINNER_LIMIT = 1024 * 1024
 ANALYSIS_FILES = {
-    "analysis.json", "descriptors.jsonl", "evaluation.json",
+    "analysis.json", "descriptors.jsonl", "evaluation.json", "stars.json",
     "winners/fitness.evolution", "winners/fastest_lap.evolution", "winners/clean_laps.evolution",
 }
 HEX64 = re.compile(r"^[0-9a-f]{64}$")
@@ -74,7 +74,7 @@ class BundleError(ValueError):
 
 
 def _analysis_member_limit(name: str) -> int:
-    if name in {"analysis.json", "evaluation.json"}:
+    if name in {"analysis.json", "evaluation.json", "stars.json"}:
         return ANALYSIS_JSON_LIMIT
     if name.startswith("winners/") and name.endswith(".evolution"):
         return ANALYSIS_WINNER_LIMIT
@@ -329,6 +329,20 @@ def load_analysis_archive(raw: bytes) -> tuple[dict[str, Any], dict[str, bytes]]
     if mode == "evaluate" and any(winners[role]["status"] != "unavailable" for role in winners):
         raise BundleError("evaluation analysis cannot select winners")
     expected_files = {"analysis.json", "descriptors.jsonl"}
+    if "stars.json" in inner:
+        from star_check import validate_star_check
+        star_check = _parse_json(inner["stars.json"], limit=ANALYSIS_JSON_LIMIT, label="star check")
+        primary_sha = (winners["fitness"]["artifact"]["sha256"] if mode == "train"
+                       else conditions["network_sha256"])
+        try:
+            validate_star_check(star_check, network_sha256=primary_sha,
+                                track_sha256=conditions["track_sha256"],
+                                vehicle_type=conditions["vehicle_type"], backend=analysis["execution_backend"])
+            if star_check["collision_elimination"] != conditions["collision"]:
+                raise ValueError("Star check elimination setting mismatch")
+        except (KeyError, TypeError, ValueError) as exc:
+            raise BundleError("Star check does not match this result") from exc
+        expected_files.add("stars.json")
     if mode == "train":
         expected_files |= {f"winners/{role}.evolution" for role in winners if winners[role]["status"] == "available"}
     else:

server.py

@@ -157,6 +157,8 @@ def create_app(worker=run_reported,store=None,gpu_worker=None,track_library=None
         if isinstance(bundle_files,dict) and 'analysis_archive.gz' in bundle_files:
             required.add('analysis-archive.gz')
             required.update(name for name in bundle_files if name.startswith('analysis/'))
+            if 'analysis/stars.json' in bundle_files:
+                required.add('star-check.txt')
             key_match=AUTOSAVE_APP_KEY.fullmatch(result.get('key',''))
             if key_match is None:
                 raise HTTPException(502,'Storage operation failed')

star_check.py

@@ -0,0 +1,524 @@
+"""Ephemeral challenge-condition check for one fixed network replay.
+
+This predicts conditions attached to a supplied hosted track. It never grants
+or persists original-game stars, and never scores an evolutionary population.
+"""
+from __future__ import annotations
+
+import math
+import re
+from collections.abc import Mapping
+
+MAX_TICKS = 18_000
+MAX_ROWS = 18_001
+MAX_CHALLENGES = 64
+EPSILON = 1e-5
+SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
+SUPPORTED = {
+    "LapChallenge", "LapInTimeChallenge", "AnyLapInTimeChallenge",
+    "ScoreChallenge", "ScoreInTimeChallenge", "NegativeLapChallenge",
+    "NegativeLapInTimeChallenge", "NegativeScoreChallenge",
+    "LimitedNeuronsLapChallenge", "ScoreWithMoreNeuronsThanChallenge",
+    "LapWithMoreNeuronsThanChallenge",
+    "LimitedSensorsLapChallenge", "LapWithVehicleChallenge",
+    "EliminationEnabledLapChallenge", "EliminationDisabledLapChallenge",
+    "EliminationEnabledScoreChallenge", "EliminationDisabledScoreChallenge",
+    "DriftInTimeChallenge", "TopSpeedInTimeChallenge", "SlowLapChallenge",
+    "CollisionLapChallenge",
+}
+POPULATION_OR_HISTORY = {
+    "RaceChallenge", "SimultaneousPositiveNegativeLapChallenge",
+    "NoEliminationInTimeChallenge", "LimitedAgentsCountLapChallenge",
+    "LimitedAgentsCountScoreChallenge", "LimitedEliminationCountLapChallenge",
+    "LimitedEliminationCountScoreChallenge", "LapInGenerationsChallenge",
+    "ScoreInGenerationsChallenge",
+}
+
+# These are SHA-256 hashes of exact compressed hosted replica track files. The
+# matching captured game tracks use opponent races, while hosted replicas carry
+# placeholder 1/2/3 lap challenges. Never report those placeholders as stars.
+_ORIGINAL_RACE_TRACKS = {
+    "14b52a7cbbf7de5606c772c74730c0e8776f39ed72955fef5ae1f7c2d8ccef77": (
+        ("52746c9d-bedb-4679-8de1-1339478b250a", "R01 Easy"),
+        ("b3389d76-a6aa-41b9-a0c3-af4ab7c45d0a", "R01 Medium"),
+        ("5a5a9ce3-60c6-4a99-a64a-e3789ff1af4a", "R01 Expert"),
+    ),
+    "653286b00f2f04450e698d8b8e9d4ecb268064b323b182d2de9db7d017b22238": (
+        ("4c8ea415-592d-4825-b066-041eaed6401b", "R02 Easy"),
+        ("da2851f3-6cc8-4c50-b84a-e291ca2ae1fe", "R02 Medium"),
+        ("fbee8c65-d248-4e23-a021-e89e6314012d", "R02 Expert"),
+    ),
+    "0e1b42ce51ae91a8702e173013a090d00145e518bb47d7a659cb1d1fdff011b5": (
+        ("bcaf746b-9131-4c41-aea5-319ccde5784d", "R03 Easy"),
+        ("21b8fabb-c77d-4f74-8e84-7b70521459c4", "R03 Medium"),
+        ("5b4dfbef-2bbb-4bd2-9e37-23ccc8b4bac1", "R03 Expert"),
+    ),
+    "d7b89d64e118506e6cec259057886d9267ca4c6fab570e7ba0d6641e8f822f11": (
+        ("5ddafd37-573c-4494-a592-744e5b77d0d3", "R04 Easy"),
+        ("68f6356e-5b31-40b1-842e-ed2e476c4467", "R04 Medium"),
+        ("2610f9d7-503a-490c-ae27-99f5b0b4d00f", "R04 Expert"),
+    ),
+    "dde36ad5f627bce65d45a96d46a68497f8d446f6011c9df19ee51ce71375cba8": (
+        ("ab8c27e8-8396-4a72-b129-2b9befb436de", "R05 Easy"),
+        ("6711b983-4b76-40af-bff1-69a3ce41878c", "R05 Medium"),
+        ("350b58fa-d4dd-4fff-91b2-8dae87307997", "R05 Expert"),
+    ),
+    "9de8d912a59001ea13baa7f1b4f92884b8cddf91978f31e19f3237975713f739": (
+        ("79b8188b-ea6b-446f-b1c4-3ff2c507b563", "R06 Formula"),
+        ("af069dc8-d9a2-430d-90f2-d2687f7cbf78", "R06 Rally"),
+        ("9d26d9f4-6255-4a4d-a65a-c1849b57ed6f", "R06 Snowmobile"),
+    ),
+    "8c6764f3accb1a8372d910d57f4f681572dd40c590c4a3d03517379bb360fcd7": (
+        ("0fa65261-2c31-4117-bcc1-b4e2b223e9ba", "R07 Easy"),
+        ("22bf973d-1fee-465b-b7f8-6b4940f30ff4", "R07 Medium"),
+        ("90305aff-b44b-49ab-9e3d-ff4d054f7c21", "R07 Expert"),
+    ),
+    "6f11a9ffbcb477c9d19964566b1b612d2a94675605246e93e21f27bbbdb357ef": (
+        ("641bb72e-48aa-4d31-8ad3-d057a2e22406", "R08 Raging Bison"),
+        ("18f648c4-b239-496e-89db-f0cabc8e54b6", "R08 Ferret"),
+        ("4a832686-e433-4411-8f7f-4be20d693188", "R08 Silverfish"),
+    ),
+    "3ec0a78478cca1a4f0d2d98ac81f40783928adf271b70f0c32d295a6da2cdaa9": (
+        ("4a9ef57b-f720-4110-b943-834052261c72", "R09 301rng"),
+        ("196f36bb-786a-4a58-b043-3b1446905f8a", "R09 Mars"),
+        ("2ce49670-7b19-4f10-ac6b-ded1573bf9f9", "R09 null"),
+    ),
+    "a3bfb76422affc774b44c739b0636d08acb901fa7615b9adcb52c069f79834e1": (
+        ("5e2acbda-7374-4d91-a428-086a18142aa9", "Champion null"),
+        ("7baae2cc-c483-4323-85e6-ec38fe1929ab", "Champion Mars"),
+        ("ac17fb21-1a39-4e2d-b0fb-8364455f3eca", "Champion 301rng"),
+    ),
+}
+
+
+def _finite(value):
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    value = float(value)
+    return value if math.isfinite(value) else None
+
+
+def _integer(value, low=0, high=MAX_TICKS):
+    if isinstance(value, bool) or not isinstance(value, int):
+        return None
+    return value if low <= value <= high else None
+
+
+def _seconds(value):
+    value = _finite(value)
+    return value if value is not None and 0.0 <= value <= 300.1 else None
+
+
+def _time_parameter(value):
+    value = _finite(value)
+    return value if value is not None and 0.0 <= value <= 999.0 else None
+
+
+def _has_unobserved_deadline(challenge, horizon):
+    for key in ("TimeLimit", "TimeToReach", "MinTime"):
+        seconds = _finite(challenge.get(key))
+        if seconds is not None and seconds > horizon:
+            return True
+    return False
+
+
+def check_ticks(track, config):
+    """Bound observation ticks by config and any declared challenge deadline."""
+    base = _integer(config.get("ticks"), 1, MAX_TICKS) if isinstance(config, Mapping) else None
+    ticks = base or 1
+    challenges = track.get("Challenges", []) if isinstance(track, Mapping) else []
+    if isinstance(challenges, list):
+        for challenge in challenges[:MAX_CHALLENGES]:
+            if not isinstance(challenge, Mapping):
+                continue
+            for key in ("TimeLimit", "TimeToReach", "MinTime"):
+                seconds = _finite(challenge.get(key))
+                if seconds is not None and seconds > 0:
+                    ticks = MAX_TICKS if seconds >= MAX_TICKS / 60 else max(ticks, math.ceil(seconds * 60.0))
+    return max(1, min(MAX_TICKS, ticks))
+
+
+def _validated_observation_rows(observations, requested_ticks):
+    """Accept only the native 10 Hz tick/time sequence; never truncate it."""
+    max_tick = min(MAX_TICKS + 6, requested_ticks + 6)
+    if not isinstance(observations, (list, tuple)) or len(observations) > MAX_ROWS:
+        return [], False
+    rows = []
+    previous_tick = None
+    for index, row in enumerate(observations):
+        if not isinstance(row, Mapping):
+            return [], False
+        tick = _integer(row.get("tick"), 6, max_tick)
+        game_time = _seconds(row.get("game_time"))
+        update_count = _integer(row.get("stats_update_count"), 1, MAX_ROWS)
+        expected_time = (tick - 6) / 60.0 if tick is not None else None
+        if (tick is None or tick % 6 != 0 or game_time is None or update_count != index + 1
+                or not math.isclose(game_time, expected_time, rel_tol=0.0, abs_tol=1e-7)
+                or previous_tick is not None and tick != previous_tick + 6):
+            return [], False
+        previous_tick = tick
+        rows.append(row)
+    return rows, True
+
+
+def _shape_metadata(template):
+    try:
+        shape = template["NeuralNetwork"]["Shape"]
+        sensors = template["Sensors"]
+        vehicle = template["Type"]
+        if (not isinstance(shape, list) or not shape or len(shape) > 12
+                or any(_integer(n, 1, 4096) is None for n in shape)):
+            raise ValueError
+        if not isinstance(sensors, list) or len(sensors) > 128:
+            raise ValueError
+        if _integer(vehicle, 0, 3) is None:
+            raise ValueError
+        return sum(shape), sum(1 for sensor in sensors if isinstance(sensor, Mapping) and sensor.get("$type") == "raycast"), vehicle
+    except (KeyError, TypeError, ValueError):
+        return None, None, None
+
+
+def _approx_le(a, b):
+    return a < b or abs(a - b) < EPSILON
+
+
+def _approx_ge(a, b):
+    return a > b or abs(a - b) < EPSILON
+
+
+def _meters_to_score(meters):
+    # Captured UnitConstants.MetersToScore: 15 px/m, game score scale 5/384.
+    return (meters / (1.0 / 15.0)) * (5.0 / 384.0)
+
+
+def _threshold(challenge, key):
+    value = challenge.get(key)
+    return _finite(value)
+
+
+def _evaluate(challenge, row, meta, lap_score, elimination):
+    kind = challenge["$type"]
+    time = row["game_time"]
+    current = row["current_score"]
+    best = row["current_best_score"]
+    worst = row["worst_score"]
+    lap_count = challenge.get("LapCount", 1)
+    lap_count = _integer(lap_count, 1, 100)
+    target_lap = lap_score * lap_count if lap_count is not None else None
+
+    if kind in POPULATION_OR_HISTORY:
+        return None
+    if kind == "RaceChallenge":
+        return None
+    if kind == "LapChallenge":
+        return best >= target_lap
+    if kind == "LapInTimeChallenge":
+        limit = _time_parameter(challenge.get("TimeToReach"))
+        return None if limit is None else best >= target_lap and _approx_le(time, limit)
+    if kind == "AnyLapInTimeChallenge":
+        lap = row.get("best_lap_seconds")
+        limit = _time_parameter(challenge.get("TimeToReach"))
+        return None if limit is None else (False if lap is None else _approx_le(lap, limit))
+    if kind in ("ScoreChallenge", "ScoreInTimeChallenge", "EliminationEnabledScoreChallenge", "EliminationDisabledScoreChallenge"):
+        meters = _threshold(challenge, "MetersToReach")
+        if meters is None:
+            return None
+        reached = _approx_ge(best, _meters_to_score(meters))
+        if kind == "ScoreInTimeChallenge":
+            # Unlike lap-in-time, source ScoreInTime uses ordinary <=.
+            limit = _time_parameter(challenge.get("TimeToReach"))
+            return None if limit is None else reached and time <= limit
+        if kind == "EliminationEnabledScoreChallenge":
+            return reached and elimination is True
+        if kind == "EliminationDisabledScoreChallenge":
+            return reached and elimination is False
+        return reached
+    if kind == "NegativeLapChallenge":
+        return worst <= -target_lap
+    if kind == "NegativeLapInTimeChallenge":
+        limit = _time_parameter(challenge.get("TimeToReach"))
+        return None if limit is None else worst <= -target_lap and _approx_le(time, limit)
+    if kind == "NegativeScoreChallenge":
+        meters = _threshold(challenge, "MetersToReach")
+        if meters is None:
+            return None
+        return worst < _meters_to_score(meters) and abs(worst - _meters_to_score(meters)) >= EPSILON
+    if kind == "LimitedNeuronsLapChallenge":
+        limit = _integer(challenge.get("MaxNeurons"), 0, 100000)
+        return None if limit is None or meta["neurons"] is None else best >= target_lap and meta["neurons"] <= limit
+    if kind == "LapWithMoreNeuronsThanChallenge":
+        limit = _integer(challenge.get("MinNeurons"), 0, 100000)
+        return None if limit is None or meta["neurons"] is None else best >= target_lap and meta["neurons"] >= limit
+    if kind == "ScoreWithMoreNeuronsThanChallenge":
+        limit = _integer(challenge.get("MinNeurons"), 0, 100000)
+        meters = _threshold(challenge, "MetersToReach")
+        return None if limit is None or meters is None or meta["neurons"] is None else _approx_ge(best, _meters_to_score(meters)) and meta["neurons"] >= limit
+    if kind == "LimitedSensorsLapChallenge":
+        limit = _integer(challenge.get("MaxSensors"), 0, 128)
+        return None if limit is None or meta["vision_sensors"] is None else best >= target_lap and meta["vision_sensors"] <= limit
+    if kind == "LapWithVehicleChallenge":
+        vehicle = _integer(challenge.get("VehicleType"), 0, 3)
+        return None if vehicle is None or meta["vehicle"] is None else best >= target_lap and meta["vehicle"] == vehicle
+    if kind == "EliminationEnabledLapChallenge":
+        return None if elimination is None else best >= target_lap and elimination
+    if kind == "EliminationDisabledLapChallenge":
+        return None if elimination is None else best >= target_lap and not elimination
+    if kind == "SlowLapChallenge":
+        minimum = _time_parameter(challenge.get("MinTime"))
+        return None if minimum is None else best >= target_lap and _approx_ge(time, minimum)
+    if kind == "DriftInTimeChallenge":
+        min_drift = _time_parameter(challenge.get("MinDriftTime"))
+        limit = _time_parameter(challenge.get("TimeLimit"))
+        drift = row.get("drift_cumulative")
+        if min_drift is None or limit is None or drift is None:
+            return None
+        return _approx_le(time, limit) and drift >= min_drift
+    if kind == "TopSpeedInTimeChallenge":
+        threshold = _threshold(challenge, "TopSpeedKph")
+        limit = _time_parameter(challenge.get("TimeLimit"))
+        speed = row.get("speed_kph")
+        if threshold is None or limit is None or speed is None:
+            return None
+        return _approx_le(time, limit) and speed > threshold
+    if kind == "CollisionLapChallenge":
+        collision_limit = _integer(challenge.get("MinCollisions"), 1, 999)
+        collisions = _integer(row.get("collision_count"), 0, 4_000_000)
+        if collision_limit is None or collisions is None:
+            return None
+        # Source: candidates stay within target + 5 score units, must cross
+        # strictly beyond target, and collision count must be strictly greater.
+        return current <= target_lap + 5.0 and current > target_lap and collisions > collision_limit
+    return None
+
+
+def _track_entries(track):
+    challenges = track.get("Challenges", []) if isinstance(track, Mapping) else []
+    if not isinstance(challenges, list) or len(challenges) > MAX_CHALLENGES:
+        return []
+    entries = []
+    used_ids = set()
+    for index, challenge in enumerate(challenges):
+        if not isinstance(challenge, Mapping):
+            challenge = {"$type": "UnknownChallenge", "Text": "Invalid challenge definition"}
+        else:
+            challenge = dict(challenge)
+        cid = challenge.get("Id")
+        if not isinstance(cid, str) or not cid or len(cid) > 128 or cid in used_ids:
+            cid = f"challenge-{index + 1}"
+            suffix = 1
+            while cid in used_ids:
+                suffix += 1
+                cid = f"challenge-{index + 1}-{suffix}"
+        used_ids.add(cid)
+        challenge["Id"] = cid
+        entries.append(challenge)
+    return entries
+
+
+def needs_observations(track, track_sha256):
+    """Whether at least one provided challenge is eligible for a single-network pass."""
+    if not isinstance(track_sha256, str) or not SHA256_RE.fullmatch(track_sha256):
+        return False
+    if not _track_entries(track) or track_sha256 in _ORIGINAL_RACE_TRACKS:
+        return False
+    return any(challenge.get("$type") in SUPPORTED for challenge in _track_entries(track))
+
+
+def resolve_check(track, template, config, observations, *, network_sha256, track_sha256, backend, error=None):
+    """Resolve the supplied track's conditions against one fixed network replay."""
+    if not isinstance(network_sha256, str) or not SHA256_RE.fullmatch(network_sha256):
+        raise ValueError("network_sha256 must be lowercase SHA-256")
+    if not isinstance(track_sha256, str) or not SHA256_RE.fullmatch(track_sha256):
+        raise ValueError("track_sha256 must be lowercase SHA-256")
+    if backend not in ("cpu", "cuda"):
+        raise ValueError("backend must be cpu or cuda")
+    if not isinstance(track, Mapping) or not isinstance(config, Mapping):
+        raise ValueError("track and config must be objects")
+    source_challenges = track.get("Challenges", [])
+    if not isinstance(source_challenges, list) or len(source_challenges) > MAX_CHALLENGES:
+        raise ValueError("track challenge list is malformed or exceeds its bound")
+    ticks = check_ticks(track, config)
+    neurons, vision_sensors, vehicle = _shape_metadata(template)
+    meta = {"neurons": neurons, "vision_sensors": vision_sensors, "vehicle": vehicle}
+    elimination = config.get("collision") if isinstance(config.get("collision"), bool) else False
+    source_races = _ORIGINAL_RACE_TRACKS.get(track_sha256)
+    source_basis = ("Original built-in race challenge definitions identified by exact hosted track digest; "
+                    "opponent race assets are absent, so this is not an original-game award check." if source_races else
+                    "Track-defined conditions checked against one fresh replay of the current network; this is a prediction, not a game award.")
+    entries = _track_entries(track)
+    if source_races:
+        entries = [{"Id": cid, "$type": "RaceChallenge", "Text": f"Race against {opponent}"} for cid, opponent in source_races]
+    result_rows = []
+    if error is not None:
+        unavailable_reason = "Current-network observation is unavailable."
+    else:
+        unavailable_reason = "The bounded current-network observation was not available."
+    raw_rows, rows_valid = _validated_observation_rows(observations, ticks) if error is None else ([], True)
+    horizon = max((_finite(row.get("game_time")) for row in raw_rows), default=0.0)
+    for challenge in entries:
+        kind = challenge.get("$type") if isinstance(challenge.get("$type"), str) else "UnknownChallenge"
+        text = challenge.get("Text") if isinstance(challenge.get("Text"), str) else kind
+        text = " ".join(text.split())[:256]
+        item = {"id": str(challenge.get("Id", "unknown"))[:128], "type": kind[:96], "text": text,
+                "status": "not_checked", "reason": None, "completion_seconds": None}
+        if error is not None:
+            item["reason"] = unavailable_reason
+            result_rows.append(item)
+            continue
+        if source_races or kind == "RaceChallenge":
+            item["reason"] = "Opponent race results and controller assets are not available."
+            result_rows.append(item)
+            continue
+        if kind in POPULATION_OR_HISTORY:
+            item["reason"] = "This condition depends on population or training history, which the current-network check does not infer."
+            result_rows.append(item)
+            continue
+        if kind not in SUPPORTED:
+            item["reason"] = "This challenge type is not supported by the current-network check."
+            result_rows.append(item)
+            continue
+        if not rows_valid:
+            item["reason"] = "Observation sequence is incomplete or invalid."
+            result_rows.append(item)
+            continue
+        if not raw_rows:
+            item["reason"] = unavailable_reason
+            result_rows.append(item)
+            continue
+        lap_score = _finite(track.get("LapScore")) if isinstance(track, Mapping) else None
+        if lap_score is None or lap_score <= 0:
+            item["reason"] = "Track lap threshold is missing or invalid."
+            result_rows.append(item)
+            continue
+        missing = False
+        malformed = False
+        completion = None
+        running_best = 0.0
+        collision_impossible = False
+        for row in raw_rows:
+            time = _seconds(row.get("game_time"))
+            tick = _integer(row.get("tick"), 0, MAX_TICKS + 6)
+            current_score = _finite(row.get("current_score"))
+            callback_best = _finite(row.get("current_best_score"))
+            worst_score = _finite(row.get("worst_score"))
+            if callback_best is not None:
+                running_best = max(running_best, callback_best)
+            best_score = running_best
+            normalized = dict(row)
+            normalized.update(game_time=time, current_score=current_score,
+                              current_best_score=best_score, worst_score=worst_score)
+            required = [time is not None, tick is not None, current_score is not None,
+                        callback_best is not None, best_score is not None, worst_score is not None]
+            if kind == "AnyLapInTimeChallenge":
+                lap = _finite(row.get("best_lap_seconds"))
+                normalized["best_lap_seconds"] = lap if lap is not None and lap > 0 else None
+                required.append("best_lap_seconds" in row)
+            elif kind == "DriftInTimeChallenge":
+                drift = _finite(row.get("drift_cumulative"))
+                normalized["drift_cumulative"] = drift if drift is not None and drift >= 0 else None
+                required.append(normalized["drift_cumulative"] is not None)
+            elif kind == "TopSpeedInTimeChallenge":
+                speed = _finite(row.get("speed_kph"))
+                normalized["speed_kph"] = speed if speed is not None and speed >= 0 else None
+                required.append(normalized["speed_kph"] is not None)
+            elif kind == "CollisionLapChallenge":
+                collisions = _integer(row.get("collision_count"), 0, 4_000_000)
+                normalized["collision_count"] = collisions
+                required.append(collisions is not None)
+            if not all(required):
+                missing = True
+                malformed = malformed or tick is None
+                break
+            try:
+                if kind == "CollisionLapChallenge" and current_score > lap_score * challenge.get("LapCount", 1) + 5.0:
+                    collision_impossible = True
+                passed = False if collision_impossible else _evaluate(challenge, normalized, meta, lap_score, elimination)
+            except (KeyError, TypeError, ValueError, OverflowError):
+                passed = None
+            if passed is None:
+                missing = True
+                continue
+            if passed:
+                completion = time
+                break
+        if completion is not None:
+            item["status"] = "met"
+            item["completion_seconds"] = completion
+        elif missing:
+            item["reason"] = ("Observation fields are incomplete or invalid." if malformed else
+                               "Required evidence for this condition is unavailable.")
+        elif _has_unobserved_deadline(challenge, horizon):
+            item["reason"] = "The challenge deadline exceeds the bounded observation horizon."
+        else:
+            item["status"] = "not_met"
+            item["reason"] = "Condition was not met during the bounded current-network replay."
+        result_rows.append(item)
+    status = "no_challenges" if not result_rows else (
+        "unavailable" if error is not None or not rows_valid or not raw_rows and needs_observations(track, track_sha256)
+        else "complete")
+    if source_races and error is None:
+        status = "complete"
+    return {"schema": "ald.star-check", "version": 1, "network_sha256": network_sha256,
+            "track_sha256": track_sha256, "vehicle_type": vehicle, "execution_backend": backend,
+            "status": status, "horizon_seconds": horizon, "collision_elimination": elimination,
+            "scope": "current_network", "basis": source_basis, "challenges": result_rows}
+
+
+def validate_star_check(value, network_sha256, track_sha256, vehicle_type, backend):
+    """Raise ValueError for malformed or mismatched archive/UI star-check data."""
+    if not isinstance(value, Mapping) or set(value) != {
+        "schema", "version", "network_sha256", "track_sha256", "vehicle_type",
+        "execution_backend", "status", "horizon_seconds", "collision_elimination",
+        "scope", "basis", "challenges",
+    }:
+        raise ValueError("invalid star check keys")
+    if value["schema"] != "ald.star-check" or type(value["version"]) is not int or value["version"] != 1:
+        raise ValueError("invalid star check schema")
+    if value["network_sha256"] != network_sha256 or value["track_sha256"] != track_sha256:
+        raise ValueError("star check identity mismatch")
+    if not isinstance(network_sha256, str) or not SHA256_RE.fullmatch(network_sha256) or not isinstance(track_sha256, str) or not SHA256_RE.fullmatch(track_sha256):
+        raise ValueError("invalid star check digest")
+    if value["vehicle_type"] != vehicle_type or value["execution_backend"] != backend:
+        raise ValueError("star check execution identity mismatch")
+    if _integer(value["vehicle_type"], 0, 3) is None or backend not in ("cpu", "cuda"):
+        raise ValueError("invalid star check vehicle or backend")
+    horizon = _finite(value["horizon_seconds"])
+    if horizon is None or not 0 <= horizon <= 300.0:
+        raise ValueError("invalid star check horizon")
+    if not isinstance(value["collision_elimination"], bool):
+        raise ValueError("invalid star check elimination setting")
+    if value["scope"] != "current_network" or not isinstance(value["basis"], str) or not 1 <= len(value["basis"]) <= 1000:
+        raise ValueError("invalid star check scope or basis")
+    status = value["status"]
+    if status not in ("complete", "unavailable", "no_challenges"):
+        raise ValueError("invalid star check status")
+    challenges = value["challenges"]
+    if not isinstance(challenges, list) or len(challenges) > MAX_CHALLENGES:
+        raise ValueError("invalid star check challenge list")
+    if (status == "no_challenges") != (len(challenges) == 0):
+        raise ValueError("star check status/challenge mismatch")
+    required = {"id", "type", "text", "status", "reason", "completion_seconds"}
+    for challenge in challenges:
+        if not isinstance(challenge, Mapping) or set(challenge) != required:
+            raise ValueError("invalid star check challenge keys")
+        if not isinstance(challenge["id"], str) or not 1 <= len(challenge["id"]) <= 128:
+            raise ValueError("invalid star check challenge id")
+        if not isinstance(challenge["type"], str) or not 1 <= len(challenge["type"]) <= 96:
+            raise ValueError("invalid star check challenge type")
+        if not isinstance(challenge["text"], str) or len(challenge["text"]) > 256:
+            raise ValueError("invalid star check challenge text")
+        state = challenge["status"]
+        if state not in ("met", "not_met", "not_checked"):
+            raise ValueError("invalid star check challenge status")
+        completion = challenge["completion_seconds"]
+        if state == "met":
+            completion = _finite(completion)
+            if completion is None or not 0 <= completion <= horizon or challenge["reason"] is not None:
+                raise ValueError("invalid completed star check challenge")
+        elif completion is not None or not isinstance(challenge["reason"], str) or not 1 <= len(challenge["reason"]) <= 256:
+            raise ValueError("invalid uncompleted star check challenge")
+        if status == "unavailable" and state != "not_checked":
+            raise ValueError("unavailable star check contains evaluated challenge")
+    if len({challenge["id"] for challenge in challenges}) != len(challenges):
+        raise ValueError("duplicate star check challenge id")
+    return value

worker.py

@@ -17,6 +17,7 @@ import uuid
 from training_config import validate_config
 from build_info import build_identity
 from analysis_result import assemble_analysis
+from star_check import check_ticks, needs_observations, resolve_check
 
 MODULE_DIR = Path(__file__).resolve().parent
 # Source checkout is nested; a hosted release is flat under /app. Deployment
@@ -112,6 +113,16 @@ def network_input(data):
 
 def track_input(data):
     value=read_json(data)
+    challenges=value.get('Challenges',[])
+    if not isinstance(challenges,list) or len(challenges)>64:
+        raise ValueError('Track supports at most 64 challenge definitions')
+    for challenge in challenges:
+        if (not isinstance(challenge,dict) or not isinstance(challenge.get('$type'),str)
+            or not 1<=len(challenge['$type'])<=96):
+            raise ValueError('Invalid track challenge type')
+        for key,limit in (('Text',2048),('Id',128)):
+            if key in challenge and (not isinstance(challenge[key],str) or len(challenge[key])>limit):
+                raise ValueError('Invalid track challenge label')
     tiles=value['Tiles']
     if not isinstance(tiles,dict) or not 4<=len(tiles)<=256: raise ValueError('Track tile limit')
     start=value.get('StartTileConnection')
@@ -150,6 +161,51 @@ def vehicle_scene_template(scene_template, vehicle_type):
     # directory; uploaded JSON never supplies a template path.
     return (formula.parent/(name+'_template.json')).resolve()
 
+def check_current_network(work, command, env, track, template, config, result, track_bytes, backend):
+    """One independent fixed-weight check; its failure must not lose trained weights."""
+    network_sha=hashlib.sha256(result).hexdigest()
+    track_sha=hashlib.sha256(track_bytes).hexdigest()
+    kwargs=dict(network_sha256=network_sha,track_sha256=track_sha,backend=backend)
+    if not needs_observations(track,track_sha):
+        return resolve_check(track,template,config,[],**kwargs)
+    check_command=list(command)
+    def option(name,value):
+        check_command[check_command.index(name)+1]=str(value)
+    n=template['NeuralNetwork']
+    policy=work/'star-policy.json'
+    # The template contains the exported final leader after training, or the
+    # exact input weights after evaluation. No random population is initialized.
+    policy.write_text(json.dumps({'shape':n['Shape'],'weights':n['Weights'],'biases':n['Biases'],
+        'inputs':[f'sensor-{i}' for i in range(n['Shape'][0])],
+        'outputs':[OUTPUT_NAMES[i] for i in template['Outputs']]},allow_nan=False))
+    star_out=work/'star-result'
+    for key,value in (('--network',policy),('--init-network',policy),('--out-dir',star_out),
+                      ('--population',1),('--generations',1),('--ticks',check_ticks(track,config)),
+                      ('--mutation-start',0),('--mutation-end',0)):
+        option(key,value)
+    if '--evaluate-frozen' not in check_command:check_command.append('--evaluate-frozen')
+    check_command.append('--challenge-observations')
+    try:
+        subprocess.run(check_command,cwd=work,env=env,stdout=subprocess.DEVNULL,
+                       stderr=subprocess.DEVNULL,timeout=25,check=True)
+        from analysis_result import bounded_read, parsed
+        meta=parsed(bounded_read(star_out/'challenge-observations-meta.json',32*1024))
+        rows=bounded_read(star_out/'challenge-observations.jsonl',4*1024*1024)
+        observations=[parsed(line) for line in rows.splitlines()]
+        if (meta.get('schema')!='ald.challenge-observations' or meta.get('version')!=1
+            or meta.get('execution_backend')!=backend or meta.get('mode')!='evaluate'
+            or meta.get('frames')!=len(observations) or len(observations)>3001
+            or meta.get('requested_ticks')!=check_ticks(track,config)
+            or type(meta.get('lap_score')) not in (float,int) or not math.isfinite(meta['lap_score'])
+            or meta['lap_score']<=0):
+            raise ValueError('Invalid challenge observations')
+        check_track=dict(track,LapScore=meta['lap_score'])
+        return resolve_check(check_track,template,config,observations,**kwargs)
+    except subprocess.TimeoutExpired:
+        return resolve_check(track,template,config,[],error='The star check reached its time limit; trained weights are preserved.',**kwargs)
+    except (OSError,subprocess.CalledProcessError,ValueError,KeyError,TypeError):
+        return resolve_check(track,template,config,[],error='The star check could not obtain complete observations; trained weights are preserved.',**kwargs)
+
 def run_native(track_bytes,network_bytes,*,binary=None,importer=None,scene_template=None,with_report=False,gpu_library=None,config=None):
     started=time.perf_counter()
     config=validate_config(config)
@@ -205,6 +261,9 @@ def run_native(track_bytes,network_bytes,*,binary=None,importer=None,scene_templ
         history=[json.loads(line) for line in (out/'log.jsonl').read_text().splitlines() if line.strip()]
         last=history[-1] if history else {}
         files,summary,evaluation=assemble_analysis(out,template,result,network_bytes,track_bytes,config,'cuda' if gpu_library is not None else 'cpu',network_input)
+        stars=check_current_network(work,command,env,track,template,config,result,track_bytes,
+                                    'cuda' if gpu_library is not None else 'cpu')
+        files['stars.json']=json.dumps(stars,allow_nan=False,separators=(',',':')).encode()
         report={'mode':config['mode'],'analysis_summary':summary,'_analysis_files':files,'build':build_identity(),'state':'completed','elapsed_seconds':time.perf_counter()-started,
             'generations_completed':len(history),'generations_requested':config['generations'],'population':config['population'],
             'best_score':last.get('best_score'),'mean_score':last.get('mean_score'),